委托（delegate）

---

委托概述

将方法调用者和目标方法动态关联起来，委托是一个类，所以它和类是同级的，可以通过委托来掉用方法，不要误以为委托和方法同级的，方法只是类的成员。委托定义了方法的类型（定义委托和与之对应的方法必须具有相同的参数个数，并且类型相同，返回值类型相同），使得可以将方法当作另一个方法的参数来进行传递，这种将方法动态地赋给参数的做法，可以避免在程序中大量使用If-Else(Switch)语句，同时使得程序具有更好的可扩展性。

基础委托(Delegate)

在.Net中声明委托使用关键词delegate，委托具有多种使用方式（以下均为同步委托调用）：

    /// <summary>
    /// 普通委托基础调用方式（同步委托）
    /// </summary>
    public class Delegates
    {
        /// <summary>
        /// 定义有参无返回值委托
        /// </summary>
        /// <param name="i"></param>
        public delegate void NoReturnWithParameters(string o);
        /// <summary>
        /// 构造函数实例化
        /// </summary>
        public void DemoOne()
        {
            NoReturnWithParameters methord = new NoReturnWithParameters(this.Test);
            methord.Invoke("One-ok");
        }
        /// <summary>
        /// 赋值对象
        /// </summary>
        public void DemoTwo()
        {
            NoReturnWithParameters methord = this.Test;
            methord.Invoke("Two-ok");
        }
        /// <summary>
        /// DotNet 2.0 
        /// </summary>
        public void DemoThree()
        {
            NoReturnWithParameters methord = new NoReturnWithParameters(
                delegate (string o)
                     {
                         Console.WriteLine("有参无返回值:{0}", o);
                     }
            );
            methord.Invoke("Three-ok");
        }
        /// <summary>
        /// DotNet 3.0 
        /// </summary>
        public void DemoFour()
        {
            NoReturnWithParameters methord = new NoReturnWithParameters(
                (string o) =>
                    {
                        Console.WriteLine("有参无返回值:{0}", o);
                    }
            );
            methord.Invoke("Four-ok");
        }
        /// <summary>
        /// 委托约束
        /// </summary>
        public void DemoFive()
        {
            NoReturnWithParameters methord = new NoReturnWithParameters(
                (o) =>
                {
                    Console.WriteLine("有参无返回值:{0}", o);
                }
            );
            methord.Invoke("Five-ok");
        }
        /// <summary>
        /// 方法只有一行去则掉大括号及分号
        /// </summary>
        public void DemoSix()
        {
            NoReturnWithParameters methord = new NoReturnWithParameters((o) => Console.WriteLine("有参无返回值:{0}", o));
            methord.Invoke("Six-ok");
        }
        public void DemoSeven()
        {
            NoReturnWithParameters methord = (o) => Console.WriteLine("有参无返回值:{0}", o);
            methord.Invoke("Seven-ok");
        }
        /// <summary>
        /// 定义有参无返回值测试方法
        /// </summary>
        /// <param name="o"></param>
        private void Test(string o)
        {
            Console.WriteLine("有参无返回值:{0}", o);
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */
    }

同步委托&异步委托

同步委托：委托的Invoke方法用来进行同步调用。同步调用也可以叫阻塞调用，它将阻塞当前线程，然后执行调用，调用完毕后再继续向下进行。

异步委托：异步调用不阻塞线程，而是把调用塞到线程池中，程序主线程或UI线程可以继续执行。委托的异步调用通过BeginInvoke和EndInvoke来实现。

以下为异步委托调用方式：

    class Program
    {
        /// <summary>
        /// 定义有参无返回值委托
        /// </summary>
        /// <param name="i"></param>
        public delegate void NoReturnWithParameters(string o);
        static void Main(string[] args)
        {
            NoReturnWithParameters methord = new NoReturnWithParameters(Test);
            Console.WriteLine("主线程执行1");
            Console.WriteLine("主线程执行2");
            methord.BeginInvoke("demo-ok", null, null);
            Console.WriteLine("主线程执行3");
            Console.WriteLine("主线程执行4");
            Console.ReadKey();
        }
        /// <summary>
        /// 异步调用委托方法
        /// </summary>
        /// <param name="o"></param>
        static void Test(string o)
        {
            Console.WriteLine("有参无返回值:{0}", o);
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */
    }

因为调用BeginInvoke为异步委托，不会阻塞主线程，运行结果如下：

异步回调（Callback）

异步回调通过设置回调函数，当调用结束时会自动调用回调函数，可以在回调函数里触发EndInvoke，这样就释放掉了线程，可以避免程序一直占用一个线程。

    class Program
    {
        /// <summary>
        /// 定义有参有返回值委托
        /// </summary>
        /// <param name="i"></param>
        public delegate string ReturnWithParameters(string o);
        static void Main(string[] args)
        {
            ReturnWithParameters methord = new ReturnWithParameters(Test);
            Console.WriteLine("主线程执行1");
            Console.WriteLine("主线程执行2");
            /*
             BeginInvoke方法参数个数不确定, 最后两个参数含义固定，如果不使用的话，需要赋值null
             委托的方法无参数，这种情况下BeginInvoke中只有两个参数。
             此外，委托的方法有几个参数，BeginInvoke中从左开始，对应响应的参数。
             1.倒数第二个参数：是有一个参数值无返回值的委托，它代表的含义为，该线程执行完毕后的回调。
             2.倒数第一个参数：向即回调中传值，用AsyncState来接受。
             3.其它参数：对应委托方法的参数。
             */
            IAsyncResult asyncResult = methord.BeginInvoke("demo-ok", new AsyncCallback(Callback), "AsycState:给回调函数的参数传递在此处出传值");
            Console.WriteLine("主线程执行3");
            Console.WriteLine("主线程执行4");
            Console.ReadKey();
        }
        /// <summary>
        /// 异步调用委托方法
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        private static string Test(string o)
        {
            return "委托方法执行成功：" + o;
        }
        /// <summary>
        /// 回调函数
        /// </summary>
        /// <param name="asyncResult"></param>
        private static void Callback(IAsyncResult asyncResult)
        {
            /*
             *asyncResult为回调前异步调用方法返回值
             *AsyncResult 是IAsyncResult接口的一个实现类，引用空间：System.Runtime.Remoting.Messaging
             *AsyncDelegate 属性可以强制转换为定义的委托类型
             */
            ReturnWithParameters methord = (ReturnWithParameters)((System.Runtime.Remoting.Messaging.AsyncResult)asyncResult).AsyncDelegate;
            Console.WriteLine(methord.EndInvoke(asyncResult));
            Console.WriteLine(asyncResult.AsyncState);
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */
    }

执行结果如下：

注意：

1.异步调用只能调用一次EndInvoke,否则会报错。

2.如果不回调函数中执行EndInvoke，请在异步调用后手动执行EndInvoke方法释放资源。

异步委托线程等待 

1.【Delegate】.EndInvoke（推荐）

  public delegate void NoReturnWithParameters(string o);
  NoReturnWithParameters noReturnWithParameters = new NoReturnWithParameters(...);
       ......
  noReturnWithParameters.EndInvoke(asyncResult);

2.【IAsyncResult】.AsyncWaitHandle.WaitOne（可以定义等待时间，超过等待时间不继续等待向下执行）

 IAsyncResult asyncResult = null;
 asyncResult.AsyncWaitHandle.WaitOne(2000);//等待2000毫秒，超时不等待

3.【IAsyncResult】.IsCompleted（是IAsyncResult对象的一个属性，该值指示异步操作是否已完成。不推荐）

 IAsyncResult asyncResult = xxx.BeginInvoke(...);
 while (!asyncResult.IsCompleted)
 {
     //正在等待中
 }

内置委托（泛化委托）

 .Net Framework 提供两个支持泛型的内置委托,分别是Action<>和Func<>,在System命名空间中定义，结合lambda表达式,可以提高开发效率。

使用方式如下：

    class Program
    {
        static void Main(string[] args)
        {
            //使用Action声明委托
            Action<string> action = TestAction;
            action.Invoke("action-demo-ok");
            //使用Func声明委托
            Func<string, string> func = TestFunc;
            string result = func.Invoke("func-demo-ok");
            Console.WriteLine(result);
            Console.ReadKey();
        }
        private static void TestAction(string o)
        {
            Console.WriteLine("TestAction方法执行成功:{0}", o);
        }
        private static string TestFunc(string o)
        {
            return "TestFunc方法执行成功:" + o;
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */
    }

Action:无返回值的泛型委托，目前.NET Framework提供了17个Action委托,它们从无参数到最多16个参数。

public delegate void Action
Action	无返回值的泛型委托
Action<int,string>	传入参数int、string,无返回值的委托
Action<int,string,bool>	传入参数int,string,bool,无返回值的委托
Action<bool,bool,bool,bool>	传入4个bool型参数，无返回值的委托
Action最少0个参数，最多16个参数，无返回值。

Func:有返回值的泛型委托，.NET Framework提供了17个Func函数，允许回调方法返回值。

public delegate TResult Func
Func<int>	无参，返回值为int的委托
Func<int,string>	传入参数int,返回值为string类型的委托
Func<object,string,bool>	传入参数为object, string 返回值为bool类型的委托
Func<T1,T2,,T3,int> 表示	传入参数为T1,T2,,T3(类型)返回值为int类型的委托
Func最少0个参数，最多16个参数，根据返回值泛型返回。必须有返回值，不可为void。

本质上Action和Func都为delegate ，在System命名空间中定义（in和out用来标识变量）

除此之外还有Predicate，它是固定返回值为bool类型的泛型委托。Action和Func足够使用这里不做介绍。

注意：

1.委托定义不要太多，微软仅在MSCorLib.dll中就有进50个委托类型，而且.NET Framework现在支持泛型，所以我们只需几个泛型委托(在System命名空间中定义)就能表示需要获取多达16个参数的方法。

2.如需获取16个以上参数，就必须定义自己的委托类型。所以建议尽量使用内置委托，而不是在代码中定义更多的委托类型，这样可以减少代码中的类型数量，同时简化编码。

3.如需使用ref或out关键字以传引用的方式传递参数，就需要定义自己的委托。

内置委托（泛化委托）参数协变&逆变

协变（out）：假定S是B的子类，如果X(S)允许引用转换成X(B),那么称X为协变类。（支持“子类”向“父类”转换）
逆变（in）：假定S是B的子类，如果X(B)允许引用转换成X(X),那么称X为协变类。（支持“父类”向“子类”转换）

正如泛化接口，泛型委托同样支持协变与逆变

    public delegate void Action<in T>(T obj);
   
    public delegate TResult Func<out TResult>();

Action在System命名空间中定义支持逆变（in）

        Action<object> x =...;
        
        Action<string> y = x;    

Func在System命名空间中定义支持协变（out）

        Func<string> x =...;
            
        Func<object> y = x; 

如果要定义一个泛化委托类型，最好按照如下准则：
1.将只用在返回值的类型参数标注为协变（out）
2.将只用在参数的类型参数标注为逆变（in）

委托的兼容性

了解委托的兼容性，更易于在使用委托时使我们构建的代码具有多态性。

1.类型的兼容性：即使签名相似，委托类也互不兼容。

delegate void D1();
delegate void D2();
...
D1 d1=Method1;
D2 d2=d1;//编译时错误
D2 d2=new D2(d1);//这是允许的

如果委托实例执行相同的目标方法，则认为它们是等价的。

delegate void D();
...
D1 d1=Method1;
D2 d2=Method1;
Console.WriteLine(d1==d2);//True

如果多播委托按照相同的顺序应用相同的方法责任委托它们是等价的。

2.参数的兼容性：当调用一个方法时，可以给方法的参数提供大于其指定类型的变量。这是正常的多态行为。同样，委托也可以又大于其目标方法参数类型的参数，即逆变。

    class Program
    {
        //委托接受string类型参数
        delegate void NoReturnWithParameters(string o);
        static void Main(string[] args)
        {
            NoReturnWithParameters noReturnWithParameters = new NoReturnWithParameters(Test);
            noReturnWithParameters("demo-ok");
            Console.ReadKey();
        }
        //目标方法接受object类型参数
        static void Test(object o)
        {
            Console.WriteLine("返回值:{0}", o);
        }
    }

上述代码将参数string在调用目标方法时隐式向上转换为Object。

3.返回类型的兼容性：如果调用一个方法，得到的返回值类型可能大于请求的类型，这是正常多态行为。同样，委托的返回类型可以小于它的目标方法的返回值类型即协变。

    class Program
    {
        //委托返回object类型
        delegate object NoReturnWithParameters(string o);
        static void Main(string[] args)
        {
            NoReturnWithParameters noReturnWithParameters = new NoReturnWithParameters(Test);
            object o = noReturnWithParameters("demo-ok");
            Console.WriteLine(o);
            Console.ReadKey();
        }
        //目标方法返回string类型
        static string Test(string o)
        {
            return "返回值:" + o;
        }
    }

注意：标准事件模式的设计宗旨时再其使用公共基类EventArgs时应用逆变。例如，可以用两个不同的委托调用同一个方法，一个传递MouseEventArgs,另一个传递KeyEventArgs。

多播委托（+=&-=）

所有的委托的实例都有多播的功能,自定义委托和内置委托都有，可以通过+=和-=给委托增加和删掉不同的方法，当输入参数后，每个方法会按顺序进行迭代处理，并返回最后一个方法的计算结果。下面是简单模拟计算器的一段代码：

    class Program
    {
        public delegate int MulticastInstance(int inputA, int inputB);
        static void Main(string[] args)
        {
            MulticastInstance multicastInstance = Addition;
            multicastInstance += new MulticastInstance(Reduce);
            multicastInstance += new MulticastInstance(Multiply);
            int result = multicastInstance(10, 5);
            Console.WriteLine("最后执行得到的结果为:{0}", result);
            Console.ReadKey();
        }
        /// <summary>
        /// 加法
        /// </summary>
        /// <param name="inputA"></param>
        /// <param name="inputB"></param>
        /// <returns></returns>
        private static int Addition(int inputA, int inputB)
        {
            int result = inputA + inputB;
            Console.WriteLine("Addition方法执行结果:{0}", result);
            return result;
        }
        /// <summary>
        /// 减法
        /// </summary>
        /// <param name="inputA"></param>
        /// <param name="inputB"></param>
        /// <returns></returns>
        private static int Reduce(int inputA, int inputB)
        {
            int result = inputA - inputB;
            Console.WriteLine("Reduce方法执行结果:{0}", result);
            return result;
        }
        /// <summary>
        /// 乘法
        /// </summary>
        /// <param name="inputA"></param>
        /// <param name="inputB"></param>
        /// <returns></returns>
        private static int Multiply(int inputA, int inputB)
        {
            int result = inputA * inputB;
            Console.WriteLine("Multiply方法执行结果:{0}", result);
            return result;
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */
    }

得到的结果如下：

多播委托本质是：委托是不可变的，因此调用+=或-=的实质是创建一个新的委托实例，并把它赋值给已有变量。所有的委托类型都是从System.MulticastDelegate派生的，它又继承自System.Delegate，c#将委托中使用的+、-、+=、-=都编译成System.Delegate的静态Combine和Remove方法。

 

委托模拟观察者

能用委托解决的问题，都可以用接口解决。但再下面的情形中，委托可能是比接口更好的选择：

1.接口内之定义一个方法

2.需要多播能力

3.订阅者需要多次实现接口

下面代码是委托的观察者模式，优点是解耦且符合开放封闭原则：

public class MulticastDelegates
{
    public delegate int MulticastInstance(int inputA, int inputB);
    /// <summary>
    /// 模拟观察者
    /// </summary>
    public void Demo()
    {
        Manager manager = new Manager();
        manager.Attach(new MulticastInstance(Add));
        manager.Attach(new MulticastInstance(Reduce));
        manager.Attach(new MulticastInstance(Multiply));
        manager.Execute(10, 5);
    }
    /// <summary>
    /// Observer模式、又称呼发布订阅或监听模式
    /// </summary>
    public class Manager
    {
        private MulticastInstance Handler;

        /// <summary>
        /// 附加观察者
        /// </summary>
        /// <param name="handler1"></param>
        public void Attach(MulticastInstance handler1)
        {
            Handler += handler1;
        }
        /// <summary>
        /// 分离观察者
        /// </summary>
        /// <param name="handler1"></param>
        public void Detach(MulticastInstance handler1)
        {
            Handler -= handler1;
        }
        /// <summary>
        /// 如果观察者数量大于0即执行播委托列表中的方法
        /// </summary>
        /// <param name="inputA"></param>
        /// <param name="inputB"></param>
        public void Execute(int inputA, int inputB)
        {
            if (Handler != null)
                if (Handler.GetInvocationList().Count() != 0)
                    Handler(inputA, inputB);
        }
    }
    private int Add(int inputA, int inputB)
    {
        int result = inputA + inputB;
        Console.WriteLine("Add方法执行结果:{0}", result);
        return result;
    }
    private int Reduce(int inputA, int inputB)
    {
        int result = inputA - inputB;
        Console.WriteLine("Reduce方法执行结果:{0}", result);
        return result;
    }
    private int Multiply(int inputA, int inputB)
    {
        int result = inputA * inputB;
        Console.WriteLine("Multiply方法执行结果:{0}", result);
        return result;
    }
}

委托揭秘

委托看似很容易使用，通过delegate关键词定义，用熟悉的new构造委托实例，熟悉的方式调用回调函数，但实际上编译器和CLR在幕后做了大量工作来隐藏其复杂性。

重新审视上面计算器的一段代码：

    public delegate int MulticastInstance(int inputA, int inputB);

事实上通过反编译可看到：

编译器相当于定义了一个完整的类（继承自System.MulticastDelegate,定义四个方法：构造函数、Invoke、BeginInvoke和EndInvoke）：

 

　　　　　internal class MulticastInstance : System.MulticastDelegate//继承System.MulticastDelegate
        {
            //构造器
            public MulticastInstance(object @object, IntPtr method);
            //这个方法的原型和源代码指定的一样
            public virtual int Invoke(int inputA, int inputB);
            //实现回调方法和异步回调
            public virtual IAsyncResult BeginInvoke(int inputA, int inputB, AsyncCallback callback, object @object);
            public virtual int EndInvoke(IAsyncResult result);
        }
        /*
         * 作者：Jonins
         * 出处：http://www.cnblogs.com/jonins/
         */

所有委托类型都派生自System.MulticastDelegate类，System.MulticastDelegate派生自System.Delegate，后者又派生自System.Object。历史原因造成有两个委托类。
创建的所有委托类型豆浆MulticastDelegate作为基类，个别情况下仍会用到Delegate。Delegate类的两个静态方法Combine和Remove的签名都指出要获取Delegate参数。由于创建的委托类型派生自MulticastDelegate，后者又派生自Delegate，所以委托类型的实例是可以传递给这两个方法的。

MulticastDelegate的三个重要非公共字段

字段	类型	说明
_target	System.Object	当委托对象包装一个静态方法时，这个字段为null。当委托对象包装一个实例方法时，这个字段引用的是回调方法要操作的对象。 当委托对象包装一个实例方法时，这个字段引用的是回调方法要操作的对象。换言之 换言之，这个字段指出要传给实例方法的隐士参数的值。
_methodPtr	System.IntPtr	一个内部的整数值，CLR用它标记要回调的方法。
_invocationList	System.Object	该字段通常为null，构造委托链时它引用一个委托数组。

Delegate反编译后可看到静态方法Combine和Remove（委托的+、-、+=、-=编译后的本质）:

    [Serializable, ClassInterface(ClassInterfaceType.AutoDual), ComVisible(true), __DynamicallyInvokable]
    public abstract class Delegate : ICloneable, ISerializable
    {
        [ComVisible(true), __DynamicallyInvokable]
        public static Delegate Combine(params Delegate[] delegates);
        [__DynamicallyInvokable]
        public static Delegate Combine(Delegate a, Delegate b);
        [SecuritySafeCritical, __DynamicallyInvokable]
        public static Delegate Remove(Delegate source, Delegate value);
    }

 结语

同步委托将阻塞当前线程，等待方法执行完毕继续执行程序，相当于直接调用方法。异步委托是将方法放入线程池中执行并不阻塞主线程。异步委托从根本上说并不是多线程技术（任务Task也一样），就算异步委托内部将方法塞给线程池去执行也并不能说是开辟新线程执行方法，（线程池一定开辟新线程）这种说法并不严谨。委托本质是将调用者和目标方法动态关联起来，这是或许是我所理解的委托存在的最根本目的吧。

参考文献

CLR via C#（第4版） Jeffrey Richter

C#高级编程（第7版） Christian Nagel

果壳中的C# C#5.0权威指南 Joseph Albahari

......

---