委托进化漫谈

总结了下.NET 1.x ，2.0，3.x 下委托的不同写法

先定义个委托：

  delegate int oneDelegate(int i);
    class LambdaDemo
    {
        static int Plus(int i)
        {
            return i + i;
        }
 
        //.net 1.x 委托的写法(命名方法)
        oneDelegate d1 = new oneDelegate(Plus);
 
        //.net 2.0 委托的写法(匿名方法) 
        oneDelegate d2 = delegate(int i)
        {
            return i + i;
        };
 
        //.net 3.x 委托的写法(Lambda 表达式) 
        oneDelegate d3 = (int i) =>
        {
            return i + i;
        };
 
        //上述三种写法的作用都是创建一个委托实例
        //下面是调用oneDelegate 委托实例
        public void CommonInvoke(int i)
        {
            Console.WriteLine(d1(i));
            Console.WriteLine(d2(i));
            Console.WriteLine(d3(i));
        }
 
        //上面 onDelegate 使我们自己定义的委托类型， 现在来看看微软内置的委托类型 
        //System.Func<T,TResult>这是个泛型委托， T为参数类型、TResult 为返回值类型
        //就相当与 delegate T onDelegate(T i);但我们在定义委托时必须要确定他的参数类型、返回值类型
        //如：System.Func<int,int> 就表示一个参数为整型、返回值为整型的委托。也就是说
        //System.Func<int,int> 与 delegate int oneDelegate(int i); 效果等同。
        //现在我们可以使用System.Func<int,int> 来创建委托实例
 
        Func<int, int> ld1 = new Func<int, int>(Plus);
 
        Func<int, int> ld2 = delegate(int i)
        {
            return i + i;
        };
 
        Func<int, int> ld3 = (int i) =>
        {
            return i + i;
        };
 
        //上述三种写法的作用也都是创建一个委托实例
        //下面是调用Func<int, int> 委托实例
        public void LambdaInvoke(int i)
        {
            Console.WriteLine(ld1(i));
            Console.WriteLine(ld2(i));
            Console.WriteLine(ld3(i));
        }
运行下
        static void Main(string[] args)
        {
            LambdaDemo d = new LambdaDemo();
            //d.CommonInvoke(10);
            d.LambdaInvoke(10);
            Console.Read();
        }

两次输出的结果都是：

 可以看到：

在1.x 时候，定义、调用委托是最复杂的：

　　需要先定义委托类型，再定义跟委托签名一致的方法，最后实例化委托。

2.0 时候由于有了匿名函数、就简单些了：

 　 需要先定义委托类型，然后实例化委托的同时就定义了方法。

3.x 的时候就更简单了：

　　Func<int,int> 就定义了 委托类型，虽然都要定义委托，但写法极其简单、方便，

 　 =>也更加简化了定义匿名方法的写法了。

 总之能是能提高我们的开发效率。