C# 委托/事件本质详解

委托

一.什么是委托

IL层面
1>委托的本质就是一个类
2>继承自System.MulticastDelegate
3>委托里面内置了3个方法：Invoke(),BeginInvoke(),EndInvoke()

 

二.委托的三个步骤
1>public delegate void MyDelegate();//1.委托的声明
2>MyDelegate myDelegate = new MyDelegate(DoSomething);//2.委托的实例化（构造函数传方法）
3>myDelegate.Invoke();//3.实例调用(Invok调用)，这里等于执行了这个方法
myDelegate();//3.直接调用也和上面一行代码是一样的

 

三.委托的3大意义
1>解耦：
-好处是减少重复代码；
-解耦是解除了判断逻辑和共用逻辑之间的耦合；
-委托传递的是逻辑(逻辑就是方法)；
2>异步多线程
3>多播委托
-+=为委托实例按顺序增加方法，形成方法链，Invok()时按顺序执行
--=为委托实例移除方法，从方法链的尾部开始匹配，遇到第一个完全吻合的移除，且只移除一个；没有的也不异常
-多播委托带返回值，结果以最后的为准
-价值：一个变量保存多个方法，可以增减方法；Invok时候可顺序执行

 多播委托

啥叫做多播委托呢，说白了就是像广播一样的将消息传播到四面八方。多播委托就是一个方法链，Invoke时按照方法链顺序执行。多播委托就像糖葫芦串，执行Invoke的时候，就像吃糖葫芦串一样，从上到下的一个个的吃。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 事件
{
    public partial class Form1 : Form
    {
        public delegate void Mydelegate();
        public Form1()
        {
            InitializeComponent();
        }
        /// <summary>
        /// 多播委托，可以理解为一个变量保存多个方法，可增减；Invoke的时候顺序执行
        /// +=为委托实例按照顺序增加方法，形成方法链，Invoke时顺序执行
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            Mydelegate mydele = new Mydelegate(WriteInfo1);
            mydele += new Mydelegate(WriteInfo2);
            mydele += new Mydelegate(WriteInfo3);
            mydele.Invoke();
        }
        public void WriteInfo1()
        {
            Console.WriteLine("1");
        }
        public void WriteInfo2()
        {
            Console.WriteLine("2");
        }
        public void WriteInfo3()
        {
            Console.WriteLine("3");
        }
    }
}

当下面的代码

     /// <summary>
        /// 多播委托，可以理解为一个变量保存多个方法，可增减；Invoke的时候顺序执行
        /// +=为委托实例按照顺序增加方法，形成方法链，Invoke时顺序执行
        /// -=为委托移除方法，从方法的尾部开始匹配，遇到第一个完全吻合的，移除且移除一个；就算方法链中没有
        /// 这个方法，移除的时候也不会报错。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void button1_Click(object sender, EventArgs e)
        {
            Mydelegate mydele = new Mydelegate(WriteInfo1);
            //mydele += new Mydelegate(WriteInfo2);
            mydele += new Mydelegate(WriteInfo3);
            mydele -= new Mydelegate(WriteInfo2);
            mydele.Invoke();
        }

 

（容易入坑）单例中，事件重复注册

执行结果

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 事件
{
    public class Cat
    {
        public delegate void Mydelegate();
        public event Mydelegate MyEvent;
        public void MiaoMiao()
        {
            MyEvent?.Invoke();
        }
    }
    public partial class Form1 : Form
    {
        int i=0;
        Cat cat;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            i++;
            cat = new Cat();
            cat.MyEvent += WriteInfo1;
            cat.MyEvent += WriteInfo2;
            cat.MyEvent += WriteInfo3;
            cat.MiaoMiao();
        }
        public void WriteInfo1()
        {
            Console.WriteLine("1");
        }
        public void WriteInfo2()
        {
            Console.WriteLine("2");
        }
        public void WriteInfo3()
        {
            Console.WriteLine("3");
        }
    }
}

上面代码和下面代码实质是一样的。

 

 下面的代码执行3遍，执行结果如上图。这个之前在工作中遇到的一个问题，困扰了半天才解决。说白了，就是单例被重复注册事件了。解决办法，就是每次调用

RemoveAllEvent移除单例中注册的事件

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace 事件
{
    public class Cat
    {
        public delegate void Mydelegate();
        public event Mydelegate MyEvent;
        public void MiaoMiao()
        {
            MyEvent?.Invoke();
        }
    }
    public partial class Form1 : Form
    {
        int i = 0;
        Cat cat = new Cat();
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            //RemoveAllEvent(cat);
            i++;
            cat.MyEvent += WriteInfo1;
            cat.MiaoMiao();
        }
        public void WriteInfo1()
        {
            Console.WriteLine(i);
        }
        /// <summary>
        /// 移除所有注册事件
        /// </summary>
        public void RemoveAllEvent(Cat cats)
        {
            var newType = cats.GetType();
            foreach (var item in newType.GetEvents())
            {
                FieldInfo field = newType.GetField(item.Name, BindingFlags.Instance | BindingFlags.NonPublic);
                if(field !=null)
                {
                    object fileValue = field.GetValue(cats);
                    if(fileValue !=null && fileValue is Delegate)
                    {
                        Delegate objectDele = (Delegate)fileValue;
                        Delegate[] involkList = objectDele.GetInvocationList();
                        if(involkList !=null)
                        {
                            foreach(Delegate del in involkList)
                            {
                                item.RemoveEventHandler(cats, del);
                            }
                        }
                    }
                }
            }
        }
    }
}

 

静态事件，不同实例中重复了订阅方法

执行两次button1_Click方法，结果如下图。其中第二次执行的时候，发现输出结果都重复了。

 原因分析：

 

 

 解决办法：

直接把Global.MyEvent赋值为null，它之前的实例就无引用了，GC就会检测到并回收

 

 

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace _23_测试专用
{
    public class Global
    {
        public static Action<string> MyEvent;
        public static void FireTaskLog(string log)
        {
            MyEvent?.Invoke(log);
        }
    }
    public class MainTest
    {
        public MainTest()
        {
            Global.MyEvent += OnMyEvent;
        }

        private void OnMyEvent(string log)
        {
            Console.WriteLine(log);
        }
        public void Start()
        {
            for (int i = 0; i < 2; i++)
            {
                Global.FireTaskLog((i+1).ToString());
            }
        }
    }
    public partial class Form1 : Form
    {
        MainTest mainTest;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            mainTest = new MainTest();
            mainTest.Start();
        }
    }
}

 

事件

一.什么是事件
1>说白了，就是带event关键字的委托实例
2>事件可以限制变量外部调用，或者直接赋值
3>事件可以把一堆的动作或行为，封装出去，交给第三方指定
4>程序设计时候：
-固定部分，可以写死
-不固定部分，通过一个事件去开放接口，外部可以扩展动作

 

二.委托和事件的区别和联系
1>委托是一个类型，一个类，事件是委托的实例
2>比如委托时一个Student类，事件是“小明”实例