.Net 4.0 新特性

A.dynamic

 public class dynamicDemo
   {  
       public static void Test()
       {
        dynamic d = 100;
        d += 10;
        Console.WriteLine(d.GetType()+"    +=10 Result:\t"+d);
        d = 1.200;
        d += 10;
        Console.WriteLine(d.GetType() + "   +=10 Result:\t" + d);
        d = "string";
        d += 10;
        Console.WriteLine(d.GetType() + "   +=10 Result:\t" + d);
       }
}

B.可选（或默认）参数 ,命名参数

   public class DefaultParmDemo
    {
        //可选（或默认）参数:y/z
       public void Add(int x, int y = 10, int z = 100)
       {
          Console.WriteLine(string.Format("x({0})+y({1})+z({2})=Sum({3})",x,y,z,x+y+z));
       }
     
       public static void Test()
       {
           DefaultParmDemo demo=new DefaultParmDemo();
           demo.Add(5);
           demo.Add(5, 5);
           demo.Add(5, z: 10);
           demo.Add(5, z: 10, y: 15);
          //命名参数：方法定义的参数顺序与方法调用时的参数顺序可以不一致
       }
    }

 C.Lazy<T>

 [使用场景]
 i.当创建一个对象的子对象开销比较大时，而且有可能在程序中用不到这个子对象，
   那么可以考虑用延迟加载的方式来创建子对象。
 ii.另外一种情况就是当程序一启动时，需要创建多个对象，但仅有几个对象需要立即使用，
    这样就可以将一些不必要的初始化工作延迟到使用时，这样可以非常有效的提高程序的启动速度。

DataExample:

public class DataExample
{
    public string Title
    {
        get;
        set;
    }
    public static List<DataExample> GetExampleList()
    {
        List<DataExample> examples = new List<DataExample> {            
            new DataExample{Title="Lazy Load"},
            new DataExample{Title="Delegate"},
            new DataExample{Title="Event"},
            new DataExample{Title="Thread"}
            };
        return examples;
    }
    public static List<Lazy<DataExample>> GetLazyExampleList()
    {
        List<Lazy<DataExample>> examples=new List<Lazy<DataExample>>{            
            new Lazy<DataExample>(()=>new DataExample{Title="Lazy Load"}),
            new Lazy<DataExample>(()=> new DataExample{Title="Delegate"}),
            new Lazy<DataExample>(()=>new DataExample{Title="Event"}),
            new Lazy<DataExample>(()=>new DataExample{Title="Thread"})
        };
       return examples;
    }
}

public  class LazyDemo
 {
      
        public Lazy<List<DataExample>> DataExampleA
        {
            get;
            private set;
        }
        public List<Lazy<DataExample>> DataExampleB
        {
            get;
            private set;
        }
        
        // 第一次引用时加载
        private List<DataExample> _dataExampleC;
        public List<DataExample> DataExampleC
        {
            get
            {
                if (_dataExampleC==null)
                {
                    _dataExampleC = DataExample.GetExampleList();
                }
                return _dataExampleC;
            }
        }
        public LazyDemo()
        {
            
            //多个对象不一定都用到时
            DataExampleA = new Lazy<List<DataExample>>(
                              () => DataExample.GetExampleList());        
            DataExampleB = DataExample.GetLazyExampleList();
            
           
        }
        public override string ToString()
        {
          
            Console.WriteLine("A IsValueCreated:"
                             +DataExampleA.IsValueCreated);
            int i=0;
            foreach (var item in this.DataExampleB)
            {   
                Console.WriteLine("B Item IsCreated: " 
                      +item.IsValueCreated+"\tTitle:"+item.Value.Title);                 
                if (i++>0)
                    break;
            }
            Console.WriteLine();
            foreach (var item in this.DataExampleB)
            {
                Console.WriteLine("B Item IsCreated: " + item.IsValueCreated
                       + "\tTitle:" + item.Value.Title);   
            }

            Console.WriteLine("A IsValueCreated:"
                             +DataExampleA.IsValueCreated);
            return base.ToString();
        }

        public static void Test()
        {
            //延迟加载
            LazyDemo blogUser = new LazyDemo();
            blogUser.ToString();
        }
    }