C#学习（三）深入理解委托、匿名方法和 Lambda 表达式

前言

lambda的概念建立在委托的基础上，委托，实现了类型安全的回调方法。在.NET 中回调无处不在，所以委托也无处不在，事件模型建立在委托机制上，Lambda 表达式本质上就是一种匿名委托。本文中将完成一次关于委托的旅行，全面阐述委托及其核心话题，逐一梳理委托、委托链、事件、匿名方法和 Lambda 表达式。

委托的定义

了解委托，从其定义开始，通常一个委托被声明为：

public delegate void CalculateDelegate(Int32 x, Int32 y);

关键字 delegate 用于声明一个委托类型 CalculateDelegate，可以对其添加访问修饰符，默认其返回值类型为 void，接受两个 Int32 型参数 x 和 y，但是委托并不等同与方法，而是一个引用类型，类似于 C++中的函数指针，稍后在委托本质里将对此有所交代。

下面的示例将介绍如何通过委托来实现一个计算器模拟程序，在此基础上来了解关于委托的定义、创建和应用：

using System;

namespace DelegateAndEvent
{
    public class DeepInto
    {
        //声明一个委托
        public delegate void CalculateDelegate(Int32 x, Int32 y);

        //创建与委托关联的方法，二者具有相同的返回值类型和参数列表
        public static void Add(Int32 x, Int32 y)
        {
            Console.WriteLine(x + y);
        }

        //定义委托类型变量
        private static CalculateDelegate myDelegate;

        public static void Run()
        {
            //进行委托绑定
            myDelegate = new CalculateDelegate(Add);
            //回调 Add 方法
            myDelegate(100, 200);
        }
    }
}

上述示例，在类 DelegateEx 内部声明了一个 CalculateDelegate 委托类型，它具有和关联方法Add 完全相同的返回值类型和参数列表，否则将导致编译时错误。将方法 Add 传递给 CalculateDelegate 构造器，也就是将方法 Add 指派给 CalculateDelegate 委托，并将该引用赋给 myDelegate 变量，也就表示 myDeleage 变量保存了指向 Add 方法的引用，以此实现对 Add 的回调。

由此可见，委托表示了对其回调方法的签名，可以将方法当作参数进行传递，并根据传入的方法来动态的改变方法调用。只要为委托提供相同签名的方法，就可以与委托绑定，例如：

public static void Subtract(Int32 x, Int32 y) {
    Console.WriteLine(x - y);
}

同样，可以将方法 Subtract 分配给委托，通过参数传递实现方法回调，例如：

public static void Main()
{
    //进行委托绑定
    myDelegate = new CalculateDelegate(Subtract);
    myDelegate(100, 200);
}

多播委托和委托链

在上述委托实现中，Add 方法和 Subtract 可以绑定于同一个委托类型 myDelegate，由此可以很容易想到将多个方法绑定到一个委托变量，在调用一个方法时，可以依次执行其绑定的所有方法，这种技术称为多播委托。在.NET 中提供了相当简洁的语法来创建委托链，以+=和-=操作符分别进行绑定和解除绑定的操作，多个方法绑定到一个委托变量就形成一个委托链，对其调用时，将会依次调用所有绑定的回调方法。例如：

myDelegate = new CalculateDelegate(Add);
myDelegate += new CalculateDelegate(Subtract);
myDelegate += new CalculateDelegate(Multiply);
myDelegate(100, 200);

上述执行将在控制台依次输出 300、-100 和 20000 三个结果，可见多播委托按照委托链顺序调用所有绑定的方法，同样以-=操作可以解除委托链上的绑定，例如：

myDelegate -= new CalculateDelegate(Add);
myDelegate(100, 200);

结果将只有-100 和 20000 被输出，可见通过-=操作解除了 Add 方法。
事实上，+=和-=操作分别调用了 Deleagate.Combine 和 Deleagate.Remove 方法，由对应的 IL 可知：

.method public hidebysig static void Main() cil managed
{
.entrypoint
// 代码大小 151 (0x97)
.maxstack 4
IL_0000: nop
IL_0001: ldnull
IL_0002: ldftn void 
InsideDotNet.NewFeature.CSharp3.DelegateEx::Add(int32, int32)
//部分省略……
IL_0023: call class [mscorlib]System.Delegate [mscorlib]System.Delegate:: Combine(class [ms
corlib]System.Delegate, class [mscorlib]System.Delegate)
//部分省略……
IL_0043: call class [mscorlib]System.Delegate [mscorlib]System.Delegate:: Combine(class [ms
corlib]System.Delegate, class [mscorlib]System.Delegate)
//部分省略……
IL_0075: call class [mscorlib]System.Delegate [mscorlib]System.Delegate:: Remove(class [ms
corlib]System.Delegate, class [mscorlib]System.Delegate)
//部分省略……
IL_0095: nop
IL_0096: ret
} // end of method DelegateEx::Main

所以，上述操作实际等效于：

public static void Main()
{
    myDelegate = (CalculateDelegate)Delegate.Combine(new CalculateDelegate(Add),
        new CalculateDelegate(Subtract), new CalculateDelegate(Multiply));
    myDelegate(100, 200);
    myDelegate = (CalculateDelegate)Delegate.Remove(myDelegate, 
        new CalculateDelegate(Add));
    myDelegate(100, 200);
}

另外，多播委托返回值一般为 void，委托类型为非 void 类型时，多播委托将返回最后一个调
用的方法的执行结果，所以在实际的应用中不被推荐。

委托的本质

委托在本质上仍然是一个类，如此简洁的语法正是因为 CLR 和编译器在后台完成了一系列操作，将上述 CalculateDelegate 委托编译为 IL，你将会看得更加明白，如图：

所以，委托本质上仍旧是一个类，该类继承自 System.MulticastDelegate 类，该类维护一个带有链接的委托列表，在调用多播委托时，将按照委托列表的委托顺序而调用的。还包括一个接受两个参数的构造函数和 3 个重要方法：BeginInvoke、EndInvoke 和 Invoke。

首先来了解 CalculateDelegate 的构造函数，它包括了两个参数：第一个参数表示一个对象引用，它指向了当前委托调用回调函数的实例，在本例中即指向一个 DelegateEx 对象；第二个参数标识了回调方法，也就是 Add 方法。因此，在创建一个委托类型实例时，将会为其初始化一个指向对象的引用和一个标识回调方法的整数，这是由编译器完成的。那么一个回调方法是如何被执行的，继续以 IL 代码来分析委托的调用，即可显露端倪（在此仅分析委托关联 Add 方法时的情况）：

.method public hidebysig static void Main() cil managed
{
.entrypoint
// 代码大小 37 (0x25)
.maxstack 8
IL_0000: nop
IL_0001: ldnull
IL_0002: ldftn void 
InsideDotNet.NewFeature.CSharp3.DelegateEx::Add(int32, int32)
IL_0008: newobj instance void InsideDotNet.NewFeature.CSharp3.DelegateEx/ CalculateDelega
te::.ctor(object, native int)
IL_000d: stsfld class InsideDotNet.NewFeature.CSharp3.DelegateEx/ CalculateDelegate InsideD
otNet.NewFeature.CSharp3.DelegateEx::myDelegate
IL_0012: ldsfld class 
InsideDotNet.NewFeature.CSharp3.DelegateEx/Calculate Delegate InsideDotNet.NewFeature.CSharp
3.DelegateEx::myDelegate
IL_0017: ldc.i4.s 100
IL_0019: ldc.i4 0xc8
IL_001e: callvirt instance void InsideDotNet.NewFeature.CSharp3.DelegateEx/ CalculateDelegat
e::Invoke(int32, int32)
IL_0023: nop
IL_0024: ret} // end of method DelegateEx::Main

在 IL 代码中可见，首先调用 CalculateDelegate 的构造函数来创建一个 myDelegate 实例，然后通过 CalculateDelegate::Invoke 执行回调方法调用，可见真正执行调用的是 Invoke 方法。因此，你也可以通过 Invoke 在代码中显示调用，例如：

myDelegate.Invoke(100, 200

其执行过程和隐式调用是一样的，注意在.NET 1.0 中 C#编译器是不允许显示调用的，以后的版本中修正了这一限制。

另外，Invoke 方法直接对当前线程调用回调方法，在异步编程环境中，除了 Invoke 方法，也会生成 BeginInvoke 和 EndInvoke 方法来完成一定的工作。这也就是委托类中另外两个方法的作用。

委托和事件

.NET 的事件模型建立在委托机制之上，透彻的了解了委托才能明白的分析事件。可以说，事件是对委托的封装，从委托的示例中可知，在客户端可以随意对委托进行操作，一定程度上破坏了面向的对象的封装机制，因此事件实现了对委托的封装。
下面，通过将委托的示例进行改造，来完成一个事件的定义过程：

using System;

namespace DelegateAndEvent
{
    public class Calculator
    {
        //定义一个 CalculateEventArgs，
        //用于存放事件引发时向处理程序传递的状态信息
        public class CalculateEventArgs : EventArgs
        {
            public readonly Int32 x, y;

            public CalculateEventArgs(Int32 x, Int32 y)
            {
                this.x = x;
                this.y = y;
            }
        }

        //声明事件委托
        public delegate void CalculateEventHandler(object sender, CalculateEventArgs e);

        //定义事件成员，提供外部绑定
        public event CalculateEventHandler MyCalculate;

        //提供受保护的虚方法，可以由子类覆写来拒绝监视
        protected virtual void OnCalculate(CalculateEventArgs e)
        {
            if (MyCalculate != null)
            {
                MyCalculate(this, e);
            }
        }

        //进行计算，调用该方法表示有新的计算发生
        public void Calculate(Int32 x, Int32 y)
        {
            CalculateEventArgs e = new CalculateEventArgs(x, y);
            //通知所有的事件的注册者
            OnCalculate(e);
        }
    }
}

示例中，对计算器模拟程序做了简要的修改，从二者的对比中可以体会事件的完整定义过程，主要包括：

• 定义一个内部事件参数类型，用于存放事件引发时向事件处理程序传递的状态信息，EventArgs是事件数据类的基类。
• 声明事件委托，主要包括两个参数：一个表示事件发送者对象，一个表示事件参数类对象。
• 定义事件成员。
• 定义负责通知事件引发的方法，它被实现为 protected virtual 方法，目的是可以在派生类中覆写该方法来拒绝监视事件。
• 定义一个触发事件的方法，例如 Calculate 被调用时，表示有新的计算发生。

一个事件的完整程序就这样定义好了。然后，还需要定义一个事件触发程序，用来监听事件：

//定义事件触发者
public class CalculatorManager
{
    //定义消息通知方法
    public void Add(object sender, Calculator.CalculateEventArgs e)
    {
        Console.WriteLine(e.x + e.y);
    }

    public void Substract(object sender, Calculator.CalculateEventArgs e)
    {
        Console.WriteLine(e.x - e.y);
    }
}

最后，实现一个事件的处理程序：

public class Test_Calculator
{
    public static void Run()
    {
        Calculator calculator = new Calculator();
        //事件触发者
        CalculatorManager cm = new CalculatorManager();
        //事件绑定
        calculator.MyCalculate += cm.Add;
        calculator.Calculate(100, 200);
        calculator.MyCalculate += cm.Substract;
        calculator.Calculate(100, 200);
        //事件注销
        calculator.MyCalculate -= cm.Add;
        calculator.Calculate(100, 200);
    }
}

如果对设计模式有所了解，上述实现过程实质是 Observer 模式在委托中的应用，在.NET 中对Observer 模式的应用严格的遵守了相关的规范。在 Windows Form 程序开发中，对一个Button 的Click 就对应了事件的响应，例如：

this.button1.Click += new System.EventHandler(this.button1_Clic

用于将 button1_Click 方法绑定到 button1 的 Click 事件上，当有按钮被按下时，将会触发执行
button1_Click 方法：

private void button1_Click(object sender, EventArgs e) { }

匿名方法

匿名方法以内联方式放入委托对象的使用位置，而避免创建一个委托来关联回调方法，也就是由委托调用了匿名的方法，将方法代码和委托实例直接关联，在语法上有简洁和直观的好处。例如以匿名方法来绑定 Click 事件将变得非常简单：

button1.Click += delegate
{
    MessageBox.Show("Hello world.");
};

因此，有必要以匿名方法来实现本节开始的委托示例，了解其实现过程和底层实质，例如：

class AnonymousMethodEx
{
    delegate void CalculateDelegate(Int32 x, Int32 y);

    public static void Run()
    {
        //匿名方法
        CalculateDelegate mySubstractDelegate = delegate(Int32 x, Int32 y) { Console.WriteLine(x - y); };
        CalculateDelegate myAddDelegate = delegate(Int32 x, Int32 y) { Console.WriteLine(x + y); };
        mySubstractDelegate(100, 200);
    }
}

事实上，匿名方法和委托在 IL 层是等效的，编译器为匿名方法增加了两个静态成员和静态方法，如图：

由编译器生成的两个静态成员和静态方法，辅助实现了委托调用一样的语法结构，这正是匿名方法在底层的真相。

Lambda表达式

Lambda 表达式是 Functional Programming 的核心概念，现在 C# 3.0 中也引入了 Lambda 表达式来实现更加简洁的语法，并且为 LINQ 提供了语法基础，这些将在本书第 12 章有所交代。再次应用 Lambda 表达式来实现相同的过程，其代码为：

using System;

namespace Lambda
{
    public class LambdaExpressionEx
    {
        delegate void CalculateDelegate(Int32 x, Int32 y);

        public static void Run()
        {
            CalculateDelegate myDelegate = (x, y) => Console.WriteLine(x - y);
            myDelegate(100, 200);
        }
    }
}

分析 Lambda 表达式的 IL 代码，可知编译器同样自动生成了相应的静态成员和静态方法，Lambda 表达式在本质上仍然是一个委托。带来这一切便利的是编译器，在此对 IL 上的细节不再做进一步分析。

规则

• 委托实现了面向对象的，类型安全的方法回调机制。
• 以 Delegate 作为委托类型的后缀，以 EventHandle 作为事件委托的后缀，是规范的命名规则。
• 多播委托返回值一般为 void，不推荐在多播委托中返回非 void 的类型。
• 匿名方法和 Lambda 表达式提供了更为简洁的语法表现，而这些新的特性主要是基于编译器而实现的，在 IL 上并没有本质的变化。
• .NET 的事件是 Observer 模式在委托中的应用，并且基于.NET 规范而实现，体现了更好的耦合性和灵活性。

结论

从委托到 Lambda 表达式的逐层演化，我们可以看到.NET 在语言上的不断进化和发展，也正是这些进步促成了技术的向前发展，使得.NET 在语言上更加地兼容和优化。对于技术开发人员而言，这种进步也正是我们所期望的。
然而，从根本上了解委托、认识委托才是一切的基础，否则语法上的进化只能使得理解更加迷惑。本节的讨论，意在为理解这些内容提供基础，建立一个较为全面的概念。

写在后面

注：本文是对微软C# MVP王涛大佬的教程搬运和重新排版
本文很好的介绍了委托、匿名方法和lambda表达式，也是对前面两篇笔记的总结。

欢迎交流

交流问题请在微信公众号后台留言，每一条信息我都会回复哈~

• 微信公众号：画星星高手
• 打代码直播间：https://live.bilibili.com/11883038
• 知乎：https://www.zhihu.com/people/dealiaxy
• ：https://www.jianshu.com/u/965b95853b9f