前言

虽然关于委托的文章园子中不胜枚举，但是要充分的理解委托的概念并且灵活运用，个人觉得还是要由浅入深，逐步推进，最后再来研究它的实质，这样才能达到事半功倍的效果，如果不信，请看下文，相信我所言非虚（当然也欢迎园友们拍砖和批评）！

概念

（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 Program17     {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 Program17     {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             else46             {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方法，遍历其委托对象数组，依次调用数组中的方法