委托内部机制

　　小弟第一次写文章，还请大侠亲拍指正。(蛋疼的Chrome崩溃了 重新发一遍)

　　我们通俗点讲委托就是在一个方法中挖了一个坑，这个坑留着调用该方法的时候来填坑（给该委托赋值），这样子就可以做到需求留着调用者来完成，实现代码重用。网上有个比较经典的例子，烧水的一个程序水到达一定的温度的时候，水壶可能鸣笛报警，可能停止烧水，或者其他的可能。这件事是制造水壶的人不可预知，所以在这里挖了一坑，留着谁调用该烧水程序的人来填坑。当你填上鸣笛报警，水温到那个温度的时候就会鸣笛报警，当你填上停止烧水，到那个温度的时候就会停止烧水（其实这地方用事件更好，这里面说只是方便理解）。、

附上代码：

　　

  class Program
    {
        static void Main(string[] args)
        {

            MyDel del = new MyDel(M1);
            del += M2;
            del += M3;
            Delegate[] dels = del.GetInvocationList();
            foreach (var item in dels)
            {
                var my = item as MyDel;
                Console.WriteLine(my());
            }
            Console.WriteLine(del()); 
            Console.Read();
        }
        public static int M1()
        {
            return 1;
        }
        public static int M2()
        {
            return 2;

        }
        public static int M3()
        {
            return 3;
        }
       
    }

　　首先委托是一个数据类型，跟class，enum，struct一样。定义的委托的时候我们可以这样定义：public delegate int MyDel();其中delegate是定义委托的关键字，int是返回类型，MyDel是委托类型名，括号中可以放你需要的参数（这里面我给的无参）。

然后定义委托变量，public MyDel del=M1;其中M1是

public static int M1()

        {

            return 1;

        }

这样就在我们就可以在Main方法中del()就可以调用该方法。但是当我们实现多播委托的时候如果其中有几个方法例如

public static int M1()
        {
            return 1;
        }

        public static int M2()
        {

            return 2;

        }

        public static int M3()
        {

            return 3;

        }

我们就可以MyDel del = new MyDel(M1);

           del+= M2;

           del+= M3;

给委托进行赋值。这样调用Console.WriteLine(del())时候我们得到的结果只能是3。那我们怎么得到所有的返回值？

　　我们可以通过Delegate[] dels = del.GetInvocationList();得到Delegate数组。这样我们通过

foreach (var item in dels)
            {

                var my = item as MyDel;

                Console.WriteLine(my());

            }

可以得到每个的返回值。那大家就会问为什么可以这样的呢？

       贴上Main方法（前面已经附上了）：

static voidMain(string[] args)

        {

            MyDel del = new MyDel(M1);

            del += M2;

            del += M3;

            Delegate[] dels = del.GetInvocationList();

            foreach (var item in dels)

            {

                var my = item as MyDel;

                Console.WriteLine(my());

            }

            Console.WriteLine(del());

            Console.Read();

        }

　　我们通过反编译可以看到下面的代码：

private static void Main(string[] args)
    {
        MyDel del = new MyDel(Program.M1);
        del = (MyDel) Delegate.Combine(del, new MyDel(Program.M2));
        del = (MyDel) Delegate.Combine(del, new MyDel(Program.M3));
        Delegate[] dels = del.GetInvocationList();
        foreach (Delegate item in dels)
        {
            Console.WriteLine((item as MyDel)());
        }
        Console.WriteLine(del());
        Console.Read();
    }

　　首先我们得理解我们写的所有的委托都是继承自MulticastDelegate（抽象类），而MulticastDelegate又继承自Delegate类。在MulticastDelegate中有个重要的字段：_invocationList，Delegate中有两个重要字段是_target和_methodPtr。

　　当我们MyDel del = new MyDel(M1);的时候首先他的该委托变量会存放_methodPtr中，而_target指向的是该类型的实例地址，他指向的是Program，_invocationList就是一个空的Delegate数组(null)。

     我们通过+=实现委托链的时候，MulticastDelegate会重写Delegate类中的CombineImpl方法（我截取一部分，这里以del+=M2;为基准）：

//follow代表的是M2
protected sealed override Delegate CombineImpl(Delegate follow){
object[] objArray;
int num2;
//假如follow（M2）为null的时候返回自己
    if (follow == null)
    {
        return this;
}
//判断是否类型相同
    if (!Delegate.InternalEqualTypes(this, follow))
    {
        throw new ArgumentException(Environment.GetResourceString("Arg_DlgtTypeMis"));
}
//将follow转为MulticastDelegate类型，刚刚已经提过如果是单播委托//的时候invocationList为null
    MulticastDelegate o = (MulticastDelegate) follow;
int num = 1;
//这时候objArray2就为 null
    object[] objArray2 = o._invocationList as object[];
    if (objArray2 != null)
    {
        num = (int) o._invocationCount;
}
//将自己的invocationList转换为数组，同上得到的也是null
    object[] objArray3 = this._invocationList as object[];
    if (objArray3 == null)
{
//得到num2结果为2
        num2 = 1 + num;
        objArray = new object[num2];
    //将自己放到objArray[0]中
        objArray[0] = this;
    //将添加的委托放到objArray[1]中
        if (objArray2 == null)
        {
            objArray[1] = o;
        }
    //如果增加的委托变量也是多播委托才会走这步
        else
        {
            for (int i = 0; i < num; i++)
            {
                objArray[1 + i] = objArray2[i];
            }
        }
    //返回一个新的委托这里面返回的invocationList存放了两个Delegate数组，数组中每一个代表委托链中的一个委托实例下面的代码
        return this.NewMulticastDelegate(objArray, num2);
}..（后面代码不在写）}
//返回一个新的委托
    internal MulticastDelegate NewMulticastDelegate(object[] invocationList, int invocationCount, bool thisIsMultiCastAlready)
{
    MulticastDelegate delegate2 = Delegate.InternalAllocLike(this);
    if (thisIsMultiCastAlready)
    {
        delegate2._methodPtr = base._methodPtr;
        delegate2._methodPtrAux = base._methodPtrAux;
    }
    else
    {
        delegate2._methodPtr = base.GetMulticastInvoke();
        delegate2._methodPtrAux = base.GetInvokeMethod();
    }
    delegate2._target = delegate2;
    delegate2._invocationList = invocationList;
    delegate2._invocationCount = (IntPtr) invocationCount;
    return delegate2;
}

　　所以我们可以通过下面图来理解单播委托与多播委托：

　　这边提一点：单播委托的时候_invocationList为null，而多播委托的时候，_invocationList是一个Delegate[]，数组中每一个成员就是一个委托实例。

　　这里我们的注意的一点是委托跟字符串具有一样的特性：不可变性。我们刚开始定义委托变量MyDel del = new MyDel(M1);堆内存中分配了一块地址当del+=M2;的时候堆内存为M2分配了一块内存地址，而堆为del重写分配了一块地址用于存放del，栈中重新指向了另外一块内存地址。所以一开始的del是没有改变。这时候一开始堆内存的del（M1）跟M2就可以被垃圾回收了。

　　附上赵晓虎的图：

　　扯到这不得不提类堆内存的存放。借用我们马伦的画的一张图：

　　

　　当程序集(dll,exe)加载的时候，在appDomain堆内存中就有一块内存空间用于存放该类型的实例，例如Person类型的实例。当我们Person person=new Person()的时候，在堆内存中一块内存地址由于存放person的变量的空间。他们都会有对象空间，类型指针，同步索引块。我们当前创建的person就会指向person实例的地址，Person就会指向Person类型的实例地址。当前创建的person的类型指针会指向Person类型地址。而Person类型实例中的类型指针会指向自己。

       在图中DelDefine del=new DelDefine(person.Show)其中person实例就指向了target，而target就指向了person实例空间地址。methodPtr指向了Show方法。这样我们del()的时候，就是通过person实例调用方法。

　　好了就说这么多了，欢迎大侠们亲拍指正！！！