委托

　　.NET团队之初想要实现一种用于任何后期绑定算法的引用类型，也就是想要一种可用于对方法引用的一种结构，同时又希望它能支持单播和多播，于是委托诞生了。　　

    多播指的将多个方法调用链接在一起调用，就像一个列表一样
    单播指的是单一方法的调用，其实可以认为单播是多播的一种特例

　　委托是.NET 1.0版本的一部分（在泛型出现之前），从功能上说，委托就是一种对方法的引用，类似于函数指针，或者说，委托是对方法的一种分类引用，相同参数类型和返回类型的方法视为一类，可被同一种类型的委托引用。

　　delegate

　　声明委托使用delegate关键字，例如：　　　

    //无返回值委托类型
    public delegate void EventHandler(object? sender, EventArgs e);
    //有返回值委托类型
    public delegate Assembly? ResolveEventHandler(object? sender, ResolveEventArgs args);

　　委托还可与泛型一起使用，例如使用很多的返回值的Action委托和有返回值的Func委托：　　

    //无返回值的Action委托
    public delegate void Action();
    public delegate void Action<in T>(T arg);
    public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2);

    //有返回值的Func委托
    public delegate TResult Func<out TResult>();
    public delegate TResult Func<in T1, out TResult>(T1 arg);
    public delegate TResult Func<in T1, in T2, out TResult>(T1 arg1, T2 arg2);

　　上面Action委托和Func 委托的变体可包含多达 16 个输入参数，所以一般时候我们都不用自定义委托，当然如果需要，我们可以自行使用delegate关键字去声明委托来满足我们特殊的需求。

　　委托是一种类型，就像class关键字声明的是类类型，而delegate关键字声明的是委托类型，同样我们可以实例化委托类型：　　

    class Program
    {
        public int Multiply(int a, int b)
        {
            return a * b;
        }
        public static int Plus(int a, int b)
        {
            return a + b;
        }
        static void Main(string[] args)
        {
            //静态方法转换
            Func<int, int, int> func = Plus;
            //实例方法转换
            Func<int, int, int> func = new Program().Multiply;
            //使用new关键字
            Func<int, int, int> func = new Func<int, int, int>(Plus);
            //使用Lambda表达式
            Func<int, int, int> func = (a, b) => a - b;

            int result = func(1, 2);
        }
    }

　　上面使用4中方式来获取一个委托类型的实例，比如将方法作为参数赋值给一个委托类型，在编译时会告知编译器将方法引用转换。还有Lambda表达式，它是一种匿名委托，在Linq中经常永达。

　　总之，无论是静态方法还是实例方法，能否转换为一个委托实例取决于方法的参数类型、参数顺序、返回值类型是否与委托类型一致。

　　Delegate类和MulticastDelegate类

　　委托不仅能类一样实例化，还能像类一样调用方法，也可以创建委托类型的属性，或者将委托类型变量当做参数一样传递，总之，可以将委托类型当做一种特殊的类来使用，而这一点得益于Delegate和MulticastDelegate两个类。

　　MulticastDelegate类是Delegate类的子类，但是我们无法直接创建Delegate和MulticastDelegate的子类，因为它是由编译器自动派生的。当使用delegate关键字声明的委托，在编译时会生成一个特定的委托类型，而这个委托类型就是派生MulticastDelegate类，因此我们无需像类一样显示用继承才是使用父类的方法（我们用的数组也是类似原理，派生于Array类）。

　　虽然Delegate和MulticastDelegate两个类都是委托的父类，但是不要认为Delegate就是单播类型，MulticastDelegate就是多播类型，事实上，C#中的委托都是多播类型，比如：　　

    class Program
    {
        public static void Multiply(int a, int b)
        {
            Console.WriteLine("a*b=" + (a * b));
        }
        public static void Plus(int a, int b)
        {
            Console.WriteLine("a+b=" + (a + b));
        }
        static void Main(string[] args)
        {
            //第一个方法
            Action<int, int> action = Plus;
            //链接第二个方法（多播）
            action += Multiply;

            action(2, 3);

            //输出
            //a+b=5
            //a*b=6
        }
    }

　　需要注意的是，如果委托有返回值，那么返回的是最后一个链接方法的值，其他方法的返回值将会被丢弃：　　

    class Program
    {
        public static int Multiply(int a, int b)
        {
            Console.WriteLine("a*b=" + (a * b));
            return a * b;
        }
        public static int Plus(int a, int b)
        {
            Console.WriteLine("a+b=" + (a + b));
            return a + b;
        }
        static void Main(string[] args)
        {
            //第一个方法
            Func<int, int, int> func = Plus;
            //链接第二个方法（多播）
            func += Multiply;

            int result = func(2, 3);
            Console.WriteLine("result=" + result);

            //输出
            //a+b=5
            //a*b=6
            //result=6
        }
    }

　　注意，这里链接支持+=、-=、+、- 四个运算：　　

    +：链接两个委托，并返回新的委托链，类似于数值运算中的+运算
    -：从委托链中剔除一个指定委托，并返回提出后的委托链，如果委托链无任何委托，则返回null，类似于数值运算中的-运算
    +=：先执行+运算，再新的委托链赋值给左边的委托变量，类似于数值运算中的+=运算
    -=：先执行-运算，再新的委托链赋值给左边的委托变量，类似于数值运算中的-=运算

　　常用方法与属性

　　Invoke、BeginInvoke、EndInvoke

　　Invoke是调用委托方法，而BeginInvoke、EndInvoke是它的异步模式，例如：　　

    Func<int, int, int> func = Plus;
    int result = func(1, 2);
    //等价于
    int result = func.Invoke(1, 2);

　　因为委托类型也是应用类型，那么那也就可能为null，如果直接使用可能导致空指针异常，因此我们常将Invoke方法与null条件运算符（?.）一起使用，而非直接调用：　　

    Func<int, int, int> func = null;
    int result = func(1, 2);//将导致空指针异常
    int? result = func?.Invoke(1, 2);//但此时返回值类型可能需要使用可空类型接收

　　DynamicInvoke

　　DynamicInvoke来自Delegate类，和Invoke方法一样是调用委托用的，只不过DynamicInvoke调用的参数是一个object数组，所以它常和反射结合起来使用，用于参数情况未知的情况：　　

    Func<int, int, int> func = Plus;
    int result = (int)func.DynamicInvoke(new object[] { 1, 2 });

　　Method、Target　　

    Method：多播委托中最后一个委托方法的引用，它是一个System.Reflection.MethodInfo对象
    Target：如果多播委托中最后一个委托方法是实例方法，那么Target就是调用的实例对象，如果是静态方法，那么Target就是null

　　事件

　　事件和委托类似，只不过事件时基于一种广播订阅模式，实际上，事件是建立在对委托的基础之上的，有了委托，我们才能建立起事件模型。

　　event

　　定义一个事件使用event关键字，事件类型即委托类型，如：　　

    //点击事件
    public event EventHandler Click;

　　定义了一个事件，同样可以像委托一样进行赋值、四则运算（+=、-=、+、-）等操作，同样可以想委托一样使用Delegate类和MulticastDelegate类中的方法，比如像方法一样触发事件，或者调用Invoke方法触发事件。

　　但是事件和委托还是有区别的，事件作为委托的一种特殊用法，和委托的主要却别在于：

　　1、事件必须定义在类或者结构体等内部，换句话说，委托与类、结构体等是一个级别的，而事件与方法、属性等是一个级别的

　　2、虽然事件可以使用Delegate类和MulticastDelegate类中的方法，但是它仅限在定义这个时间的类或者结构体等内部才能，比如事件的触发（像方法调用直接触发、调用Invoke方法触发）只能在类或者结构体等内部触发，列如：　　

    class Program
    {
        static void Main(string[] args)
        {
            var btn = new Button();
            btn.Click += (sender,e) => Console.WriteLine("Click");
            //btn.Click(btn, EventArgs.Empty);//报错
            btn.OnClick();//不报错
        }
    }
    public class Button
    {
        //点击事件
        public event EventHandler Click;

        public void OnClick()
        {
            Click(this, EventArgs.Empty);
        }
    }

　　3、事件采用 += 运算表示订阅，使用 -= 表示取消订阅，虽然事件也支持 +、- 运算，但是+、- 运算也只是被限制在定义这个时间的类或者结构体等内部才能使用。

　　4、定义的事件时一个引用类型，默认是null，所以在触发前要判断，避免空指针异常，建议采用Invoke方法与null条件运算符（?.）一起使用来触发事件，事件可以使用 = 进行赋值，但是同样被限制在定义这个时间的类或者结构体等内部才能使用。

　　5、标准的事件模型应该没有返回值，确实需要返回值时，应该改用参数的引用传递特性来返回数据。

　　一个完整简单的事件例子：　　

    class Program
    {
        static void Main(string[] args)
        {
            MessageProducer messageProducer = new MessageProducer();

            Subscriber zhangsan = new Subscriber("张三");
            Subscriber lisi = new Subscriber("李四");
            Subscriber wangwu = new Subscriber("王五");

            messageProducer.Subscribe(zhangsan);
            messageProducer.Subscribe(lisi);
            messageProducer.Subscribe(wangwu);

            messageProducer.Produce("hello");

            messageProducer.Unsubscribe(lisi);

            messageProducer.Produce("hello again");
        }
    }

    public delegate void MessageProducerHandler(string message);
    public class MessageProducer
    {
        public event MessageProducerHandler MessageHandle;

        /// <summary>
        /// 订阅
        /// </summary>
        /// <param name="subscriber"></param>
        public void Subscribe(Subscriber subscriber)
        {
            Console.WriteLine($"【{subscriber.Name}】订阅了消息");
            MessageHandle += subscriber.OnMessage;
        }
        /// <summary>
        /// 取消订阅
        /// </summary>
        /// <param name="subscriber"></param>
        public void Unsubscribe(Subscriber subscriber)
        {
            Console.WriteLine($"【{subscriber.Name}】取消了消息订阅");
            MessageHandle -= subscriber.OnMessage;
        }

        /// <summary>
        /// 发布一条消息
        /// </summary>
        /// <param name="message"></param>
        public void Produce(string message)
        {
            Console.WriteLine($"发布消息【{message}】");
            MessageHandle?.Invoke(message);
        }
    }

    public class Subscriber
    {
        public Subscriber(string name)
        {
            Name = name;
        }

        /// <summary>
        /// 订阅者名称
        /// </summary>
        public string Name { get; }

        /// <summary>
        /// 消息处理方法
        /// </summary>
        /// <param name="message"></param>
        public void OnMessage(string message)
        {
            Console.WriteLine($"【{Name}】收到消息【{message}】");
        }
    }

　　打印结果：

　　总结

　　我们可以认为事件时委托的一种特殊用法，什么时候用委托，什么时候用事件，总结如下：

　　1、如果需要像一个变量使用，在某段代码后执行回调，应该使用委托，比如 linq 的语法

　　2、如果需要有返回值，应该采用委托

　　3、如果需求表现出一次订阅，长时间内接收多个信息的特性，应该使用事假模型。

　　参考文档：https://docs.microsoft.com/en-us/dotnet/csharp/delegates-overview