前言
虽然关于委托的文章园子中不胜枚举，但是要充分的理解委托的概念并且灵活运用，个人觉得还是要由浅入深，逐步推进，最后再来研究它的实质，这样才能达到事半功倍的效果，如果不信，请看下文，相信我所言非虚（当然也欢迎园友们拍砖和批评）！
概念
（1）用Delegate类表示委托，委托是一种数据结构，它引用静态方法或引用类实例及该类的实例方法。
（2）解述：委托声明了一种类型，它用一种特定的参数以及返回类型来封装方法。对于静态方法，委托对象封装要调用的方法。对于实例方法，委托对象同时封装一个实例和该实例上的方法。如果有一个委托对象和一组适当的参数，则可以用这组参数来调用委托。
委托引入
平常我们就是写一个方法，然后再传入参数直接调用。如下：
static void xsEat(string food)
{
Console.WriteLine("小三吃" + food);
}
xsEat("零食"); /*打印出小三吃零食*/
现在我们用委托来实现代码如下：
delegate void EatDelegate(string food);
class Program
{
static void Main(string[] args)
{
EatDelegate xs = new EatDelegate(xsEat);
xs("零食");
Console.ReadKey();
}
static void xsEat(string food)
{
Console.WriteLine("小三吃" + food);
}
}
我们用关键字 delegate 定义一个EatDelegate委托，在声明类的任何地方就能声明委托，委托声明的返回值和参数必须要和要调用的方法的签名一致。接下来对委托进行实例化并传入要代理的方法指针，此时实例化的对象 eat 就指向了方法 xs ，再传入参数，结果打印出小三吃零食。如果接下来有小红（xh）和小明（xm）也过来吃零食，那我们也同样写这样的方法,代码如下：
1 delegate void EatDelegate(string food);
2 class Program
3 {
4 static void Main(string[] args)
5 {
6 EatDelegate xs = new EatDelegate(xsEat);
7 xs("零食");
8 EatDelegate xh = new EatDelegate(xhEat);
9 xh("零食");
10 EatDelegate xm = new EatDelegate(xmEat);
11 xm("零食");
12 Console.ReadKey();
13 }
14
15 static void xsEat(string food)
16 {
17 Console.WriteLine("小三吃" + food);
18 }
19
20 static void xhEat(string food)
21 {
22 Console.WriteLine("小红吃" + food);
23 }
24 static void xmEat(string food)
25 {
26 Console.WriteLine("小明吃" + food);
27 }
28 }
上述分别打印出小三吃零食、小红吃零食、小明吃零食。看起来满足了需求，但是我们仔细想想明明是吃零食为什么还要实例化三次呢？代码能不能精简了，当然有办法，继续是委托，这个时候就要用到 委托链 了。所以我们对控制台的代码进行改写如下：
static void Main(string[] args)
{
EatDelegate xs = new EatDelegate(xsEat);
EatDelegate xh = new EatDelegate(xhEat);
EatDelegate xm = new EatDelegate(xmEat);
EatDelegate eat;
eat = xs + xh + xm;
eat("零食");
Console.ReadKey();
}
我们只需要把委托实例添加到委托链中即可同样达到了上述的效果。此时小三、小红和小明三个一起扎堆吃零食，后来陆陆续续的走了，通过这样一段描述我们用强大的委托链来实现，代码如下：
1 static void Main(string[] args)
2 {
3 EatDelegate xs = new EatDelegate(xsEat);
4 EatDelegate xh = new EatDelegate(xhEat);
5 EatDelegate xm = new EatDelegate(xmEat);
6
7 EatDelegate eat;
8 Console.WriteLine("小三、小红和小明一起吃零食");
9 eat = xs + xh + xm;
10 eat("零食");
11 Console.WriteLine("小三有约出去了，就剩下小红和小明吃零食了");
12 eat -= xs;
13 eat("零食");
14 Console.WriteLine("小红也走了，就剩下小明一个人吃零食了");
15 eat -= xh;
16 eat("零食");
17 Console.ReadKey();
18 }
结果运行如图所示：
我们由此知道-=或者+=号来更容易的对委托链中的元素进行操作，这样一来我们可以随意而且是任意妄为的对其元素进行操作。对于上面的方法我们继续进行精简，由于方法比较简单，微软大大为我们提供了一个便捷的方式来实现那就是 匿名方法 。我们将代码进行改写如下：
delegate void EatDelegate(string food);
class Program
{
static void Main(string[] args)
{
EatDelegate eat = null;
eat += delegate(string food) { Console.WriteLine("小三吃" + food);};
eat += delegate(string food) { Console.WriteLine("小红吃" + food); };
eat += delegate(string food) { Console.WriteLine("小明吃" + food); };
eat("零食");
Console.ReadKey();
}
}
通过匿名方法使得我们能更加方便的创建委托和使用委托。
通过上述我们不免心生疑问，它只能对静态方法进行调用，难道不能对动态方法进行调用呢？同时上面的代码未免有些冗余，也不能体现C#面向对象的思想!所以，鉴于此，我们对上述代码继续进行改写，如下：
1 public class Person
2 {
3 public string Name { get; set; }
4
5 public Person(string name)
6 {
7 this.Name = name;
8 }
9
10 public void Eat(string food)
11 {
12 Console.WriteLine(this.Name + "吃" + food);
13 }
14 }
15 delegate void EatDelegate(string food);
16 class Program
17 {
18 static void Main(string[] args)
19 {
20
21 Person xs = new Person("小三");
22 Person xh = new Person("小红");
23 Person xm = new Person("小明");
24 EatDelegate xsEat = new EatDelegate(xs.Eat);
25 EatDelegate xhEat = new EatDelegate(xh.Eat);
26 EatDelegate xmEat = new EatDelegate(xm.Eat);
27 EatDelegate eatChain = null;
28 Console.WriteLine("小三、小红和小明一起吃零食");
29 eatChain = xsEat + xhEat + xmEat;
30 eatChain("零食");
31 Console.WriteLine("小三有约，出去剩下小红和小明吃零食");
32 eatChain -= xsEat;
33 eatChain("零食");
34 Console.WriteLine("小红也走了，只剩下小明一个人吃零食");
35 eatChain -= xhEat;
36 eatChain("零食");
37 Console.ReadKey();
38 }
39 }
结果和之前的效果一样：
接下来我继续进行深入的改进，看到这里相信你也明白，方法是可以作为参数进行传递的，那么委托作为代理对象是不是可以作为方法的参数进行传递呢？？我们试试，对上面代码继续进行改造，因为三个人吃零食是不确定的，所以会用到不确定参数数组，以及要吃的食物参数，所以改造如下：
1 public class Person
2 {
3 public string Name { get; set; }
4
5 public Person(string name)
6 {
7 this.Name = name;
8 }
9
10 public void Eat(string food)
11 {
12 Console.WriteLine(this.Name + "吃" + food);
13 }
14 }
15 delegate void EatDelegate(string food);
16 class Program
17 {
18 static void Main(string[] args)
19 {
20
21 Person xs = new Person("小三");
22 Person xh = new Person("小红");
23 Person xm = new Person("小明");
24 EatDelegate xsEat = new EatDelegate(xs.Eat);
25 EatDelegate xhEat = new EatDelegate(xh.Eat);
26 EatDelegate xmEat = new EatDelegate(xm.Eat);
27 EatDelegate eatChain = null;
28 Console.WriteLine("小三、小红和小明一起吃零食");
29 EatSomething("零食", xsEat, xhEat, xmEat);
30 Console.WriteLine("小三有约，出去剩下小红和小明吃零食");
31 EatSomething("零食", xhEat, xmEat);
32 Console.WriteLine("小红也走了，只剩下小明一个人吃零食");
33 EatSomething("零食", xmEat);
34 EatSomething(null, null);
35 Console.ReadKey();
36 }
37
38 static void EatSomething(string food, params EatDelegate[] ed)
39 {
40 EatDelegate eatChain = null;
41 if (ed == null)
42 {
43 Console.WriteLine("都走了，没人吃零食");
44 }
45 else
46 {
47 foreach (var chain in ed)
48 {
49 eatChain += chain;
50 }
51 eatChain(food);
52 Console.WriteLine();
53 }
54 }
55 }
结果打印出：
上述我们就实现了将委托作为参数进行传递并进行动态的调用 ！
至此，零食也吃完了，想必你对委托有了一定的了解了，那么难道你没有疑问？委托这么强大，它到底是什么东西？委托链又是怎样实现的呢？请看下文
委托实质
我们运用反编译工具查看上述生成的应用程序的IL代码，如图：
由图中我们得出的信息是：（1）我们声明的委托 EatDelegate 原来是个类，而且还是可不可继承的密封类。（2）该委托还继承多播委托 MulticastDelegate ，并且该多播委托最终继承于 Delegate ，接下来我们看看这个委托：
我们注意到在这委托里面有个IntPtr，后面接着的变量 _methodPtr 这个就是方法指针，我们说到委托链就是存的方法指针，那有很多方法它是怎么将这么多方法指针添加进去的呢？之前看过园友老赵中一篇文章，通过IL代码可以直接看c#代码，只是把你编写的C#代码进行了再一次编译而已于是我查看我写的 EatSomething 方法如图：
方法中添加委托链这一段 eatChain += chain; 被编译成如图，于是我点击查看委托中的 Combine 方法，进去后又看到一个方法如图：
若是在一个委托中添加另外一个委托，先是调用Delegate中的Combine方法，若检测第一个委托不为空则调用CombineImpl方法，将新添加的委托b添加进去，此时我查看CombineImpl方法，后面紧着就是出错抛异常,而且是个虚方法，确定应该是被重写了，既然声明的委托继承于多播委托，多播委托继承委托（Delegate），肯定是在这两个委托类中，终于在多播委托 MulticastDelegate 中重写了这个方法，如图：
接着查看其方法得到如下
通过这幅图和上幅图看到，多播委托中 _invovationList object对象在CombineImpl中被转换成了数组，同时将其num初始化为1，并将多播委托中的要添加的方法指针数量 _invocationCount 赋给num，一直往下，当其添加的数量不够时，此时将 _invovationList 重新创建数组，数组长度再赋值，有点类似StringBuilder！所以委托链的整个过程就是：新添加的委托方法将新创建一个委托对象，并将其方法指针存入最终的父类的变量Intptr中，同时将创建的对象添加到委托数组中去。
Invoke
声明委托后查看其IL代码都有三个方法，最主要的是Invoke方法，如图：
咦，发现里面怎么有个参数food同时和声明委托方法签名一致。于是试试将声明委托的返回值改为有返回值的，此时编译生成再来查看果然是一样的。也就是说当你实例化委托对象所指的方法时，此时同样可以用实例化委托对象的 Invoke 指向该方法，也就是说调用委托其实就是调用委托中的Invoke方法，并遍历委托里面的数组，依次调用里面的方法。
总结
（1）声明委托的本质是声明一个类，并且该声明委托extends=>MulticastDelegate=>Delegate
（2）委托链的本质就是新添加的方法将创建一个新的委托对象，并将其方法指针存入最终父类Delegate中的变量Intptr中，与此同时将新创建的对象添加到委托的对象数组中去
（3）调用委托的本质是调用实例化委托对象中的Invoke方法，遍历其委托对象数组，依次调用数组中的方法
来源：https://www.cnblogs.com/CreateMyself/p/4716236.html