C# 事件

小鱼儿 2023-07-25 09:24 12阅读 0赞

因为对事件仍有感到迷惑之处，所以就专门写篇笔记来整理一下思路。

### 文章目录 ###

*  一、什么是事件？
 *  二、为什么会有事件？
 *   *  2.1多播委托
     *  2.2事件的实现
 *  三、完整的事件

# 一、什么是事件？ #

1、定义  
Microsoft官方将事件定义为：事件是一种使对象或类能够提供通知的成员，原文如下。

> Events enable a class or object to notify other classes or objects when something of interest occurs. The class that sends (or raises) the event is called the publisher and the classes that receive (or handle) the event are called subscribers.

从他的定义可以看出，“事件”是隶属于一个主体的，如果没有这个主体(某个对象或是类)，那么事件也就变得没有意义。除此之外呢，就是事件既然是使得主体变得具有“通知能力”，那么事件的作用也就显而易见了，它被用于对象或类之间进行“消息传递”。  
2、组成部分  
事件模型的组成部分有以下这五个部分：

> (1)事件的拥有者(event source)。这也就是上面说的拥有事件的主体。  
> (2)事件本身(event)。也就是一种可以发送“消息”的成员。  
> (3)事件的响应者(event subscriber)。接收事件所发送的消息的对象。  
> (4)事件处理器(event handler)。本质上是一种C/C++中的回调函数，当接收到事件之后，该函数将会被调用做出相应的动作。  
> (5)事件的订阅。也就是事件处理器要和事件本身建立一种契约关系，利用委托来实现。

我们在Windows编程的过程中其实会经常遇到事件，如Click、MouseDown、MouseUp等等诸如此类，正是有了事件的驱动，才使得我们点击鼠标就能够调用我们编写的代码的内部逻辑，以此来达到我们期望的效果。

# 二、为什么会有事件？ #

这个问题也是一直让我比较迷惑的地方，明明已经有了委托了，为什么还要再搞出来一个事件的这个概念呢？而且很多书上都说事件本身其实是基于委托来实现的，这就是我更加感到困惑了，那么要尝试解释这个问题就要先看一看委托的缺陷了。

## 2.1多播委托 ##

> 当一个委托对象引用了一系列的方法时，也就是说这一系列的方法订阅了一个委托对象(一对多的关系)，并且这些方法将被顺序调用，这样的委托就被称之为多播委托。这样一来就可以实现一个消息通知多个订阅的对象。

接下来我们以一段代码来演示一下多播委托的用法：  
Student.cs文件

Program.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        class Program
        { 
            static void Main(string[] args)
            { 
                Student stu1 = new Student() {  ID = 1, PenColor = ConsoleColor.Yellow };
                Student stu2 = new Student() {  ID = 2, PenColor = ConsoleColor.Green };
                Student stu3 = new Student() {  ID = 3, PenColor = ConsoleColor.Red };
                Action action1 = new Action(stu1.DoHomeWork);
                action1 += stu2.DoHomeWork;	//添加引用方法
                action1 += stu3.DoHomeWork;
                action1.Invoke();		//调用委托，开始做作业
    
                Console.ReadKey();
            }
        }
    }

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]  
这其中的代码很简单，但是要注意的是C\#中的委托实例具有不变性，这一点与String类的特点非常相似。以前我对这个不变性并没有什么感触，不过现在我是有点感触的，毕竟吃了很多次亏。我们可以将其中的代码，如下所示：

Action action1 = new Action(stu1.DoHomeWork);
    action1 += stu2.DoHomeWork;	//添加引用方法
    action1 += stu3.DoHomeWork;
    action1.Invoke();		//调用委托，开始做作业

改为下面的代码，再运行程序。

Action action1 = new Action(stu1.DoHomeWork);
    action1 += stu2.DoHomeWork;
    
    Action action2 = action1;	//将委托action1赋给action2
    action2 += stu3.DoHomeWork;
    
    action1.Invoke();

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]  
运行的结果会让人更能理解什么是：委托的不变性。其实就每一个委托实例而言，他们都掌握着一个操作列表(调用列表)，也就是说他们根据这个操作列表来进行方法的调用。而像上面的使用“+=”操作符来进行引用方法的添加，实际上是在调用Delegate.combine方法，而这个方法首先会创建一个新的委托实例，然后再把两个委托实例的操作列表进行连接，最后再把新的操作列表赋给新的委托实例。  
为了能更好的理解，可以看下面的实际代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 2]  
那么既然“+=”“-=”会创建一个全新的委托实例，那么我就有理由怀疑“=”也会创建一个全新的委托实例，为了验证我的猜想，我添加了下面的几行代码：

GCHandle hander1 = GCHandle.Alloc(action1);
    var pin1 = GCHandle.ToIntPtr(hander1);
    GCHandle hander2 = GCHandle.Alloc(action2);
    var pin2 = GCHandle.ToIntPtr(hander2);
    
    Console.WriteLine("{0} {1}", pin1, pin2);

输出的结果为：  
![在这里插入图片描述][20200414173808229.png]

两个变量指向的内存地址果然不一样，那这就证明了“=”操作符也会产生一个新的委托实例，那么委托为啥要这样做呢，其实委托的这种做法有利于保证在使用委托过程中的线程安全性和一致性，这在多线程程序中会显得尤为重要。  
总的来说，现在这样看起来很美好，委托好像没什么缺点，但是如果再把代码改为下面这样呢？  
Student.cs

class Student
    { 
        public int ID {  get; set; }
    
        public ConsoleColor PenColor {  get; set; }
    
        public void DoHomeWork()
        { 
            for (int i = 0; i < 3; i++)
            { 
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} doing homework {1} hour(s)", this.ID, i);
                Thread.Sleep(1000);
            }
        }
    
        public void DontWork()
        { 
            Console.WriteLine("Student {0} dont work!!!",this.ID);
            throw new Exception("出现异常");
        }
    }

Program.cs

Action action1 = new Action(stu1.DontWork);
    action1 += stu2.DoHomeWork;
    action1.Invoke();

那么运行程序，结果是直接报出异常，委托实例中的第一个方法就出现错误，则会直接影响到下面的所有的引用方法的调用，这是因为多播委托是顺序调用，而不是同时调用，也就是方法仍然处在同一个线程上，因此委托的这种异常传播也就成了委托的缺陷之一。再就是委托如果存在返回值也会存在 一些问题，因为所有的引用方法都会返回一个消息数据，那么发布者就会面临要选择哪个返回的消息这样的一个难题，所以遇到这种情况往往只能通过使用GetInvocationList()来遍历委托所引用的方法，逐个的获取返回值。除此之外呢，如果委托类型中使用了ref或out参数都需要区别对待。

但是上面的这些缺陷都是委托自身内部机制的缺点，即使有了事件也并不能去消除或避免这些缺陷，而以下的这两个关键的问题，才是产生事件的导火索。  
1、事件的订阅问题。

Action action1 = new Action(stu1.DontWork);
    action1 = stu2.DoHomeWork;

![在这里插入图片描述][20200414213602789.png]  
我们可能会不小心将“+=”操作符写成“=”操作符而引发错误。  
2、事件的发布问题。  
在上述的代码中添加一个teacher类，做如下的操作：  
teacher.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        class Teacher
        { 
            public Action doHomeWork;
        }
    }

using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        class Program
        { 
            static void Main(string[] args)
            { 
                Student stu1 = new Student() {  ID = 1, PenColor = ConsoleColor.Yellow };
                Student stu2 = new Student() {  ID = 2, PenColor = ConsoleColor.Green };
                Student stu3 = new Student() {  ID = 3, PenColor = ConsoleColor.Red };
    
                Teacher teacher=new Teacher();
                teacher.doHomeWork += stu2.DoHomeWork;
    
                teacher.doHomeWork();	//被直接调用
                Console.ReadKey();
            }
        }
    }

![在这里插入图片描述][20200414214707989.png]

此时的程序的确可以正常的运行，但是teacher对象应禁止Program类像这样直接调用它的委托字段，因为这可能会造成胡乱的传递消息(消息通知过多)，这就像是我们也都不喜欢我们的手机整天响来响去一样，太烦人。  
这两个关键问题因为并不是委托本身的缺陷，而是一些外部的逻辑缺陷，所以这是可以通过一些手段来避免的此类问题，也由此产生了事件这一概念，而事件的主要作用也就是要避免委托的这些外部逻辑缺陷。

## 2.2事件的实现 ##

那么既然理解了为什么会有事件，接下来就需要去讨论一下事件是怎样去弥补委托的缺陷的。最简单的方式就是在委托字段前面加上event关键字就可以实现封装委托的发布和订阅问题，从而解决上述的两个问题。

![在这里插入图片描述][20200415081549151.png]

效果是立竿见影的，“=”和直接调用都已经被禁止。  
反编译之后再来看一下Teacher类：  
C\#代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 3]  
IL代码：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 4]  
此时的event关键字在编译器里的主要的部分应该是下面这样的形式。

private Action doHomeWork;
    public event Action doHomeWork
    { 
    	add	{ add_doHomeWork+=value;}
    	remove { remove_doHomeWork-=value;}
    }

也就是说，我们使用事件的“+=”或“-=”其实都是在调用add和remove这两个方法,以这两个方法来实现对private委托字段进行添加或删除引用方法。

# 三、完整的事件 #

在上述的例子中，我用的是Action这个微软已经在C\#语言中内置的委托模板，而为了区别普通的委托和用于事件的委托，很多书上建议我们去自定义一个名字后缀为EventHandler这样一个委托，如下所示：

class Teacher
    { 
        //添加event关键字后悔禁止委托字段使用赋值操作符，并且只有包容类Teacher才能调用它
        public event doHomeWorkEventHandler doHomeWork;  //将事件设置为空
    }
    public delegate void doHomeWorkEventHandler();	//带有后缀EventHandler，可以提高阅读性

这样我们就可以很容易的知道哪个是用于事件的委托类型，哪个是普通的委托类型，提高了代码的阅读性。这样最终的代码就是下面这种形式：  
Teacher.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        class Teacher
        { 
           
            //添加event关键字后悔禁止委托字段使用赋值操作符，并且只有包容类Teacher才能调用它
            public event doHomeWorkEventHandler doHomeWork;  //将事件设置为空
    
            public void Notify()    //发布通知
            { 
                this.doHomeWork.Invoke();   //开始传递消息,此时doHomeWork只能在Teacher类中被调用
            }
        }
    
        public delegate void doHomeWorkEventHandler();
    }

Student.cs

Program.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Runtime.InteropServices;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        class Program
        { 
            static void Main(string[] args)
            { 
                Student stu1 = new Student() {  ID = 1, PenColor = ConsoleColor.Yellow };
                Student stu2 = new Student() {  ID = 2, PenColor = ConsoleColor.Green };
                Student stu3 = new Student() {  ID = 3, PenColor = ConsoleColor.Red };
    
                Teacher teacher = new Teacher();
                teacher.doHomeWork += stu1.DontWork;
                teacher.doHomeWork += stu2.DoHomeWork;
    
                teacher.Notify();   //发布通知
                Console.ReadKey();
            }
        }
    }

但是这还不能够适用于大多数的情况，因为在上面的代码中我进行委托的是无参数的方法，而我们实际编程过程中应该经常会看到下面这种情况：  
Teacher.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;
    
    namespace Event
    { 
        public class Teacher
        { 
            //添加event关键字后悔禁止委托字段使用赋值操作符，并且只有包容类Teacher才能调用它
            public event doHomeWorkEventHandler doHomeWork;  //将事件设置为空
    
            public int count;   //用于记录有多少学生做作业了
            public void Notify()    //发布通知
            { 
                NofityEventArgs e = new Event.NofityEventArgs();
                this.doHomeWork.Invoke(this,e);   //开始传递消息，将发布者本身和消息内容传递给订阅者
            }
        }
    
        public delegate void doHomeWorkEventHandler(Teacher sender,NofityEventArgs e);      //创建一个委托类型
        public class NofityEventArgs        //事件参数，也就是老师布置作业的内容，做什么作业
        { 
            public bool math = false;
            public bool chinese = true;
        }
    }

Student.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    
    namespace Event
    { 
        class Student
        { 
            public int ID {  get; set; }
    
            public ConsoleColor PenColor {  get; set; }
    
            public void DoHomeWork(Teacher sender,NofityEventArgs e)
            { 
                Console.ForegroundColor = this.PenColor;
                if (e.chinese)
                { 
                    Console.WriteLine("Student {0} begin to do Chinese homework!",this.ID);
                }
                else if (e.math)
                { 
                    Console.WriteLine("Student {0} begin to do Math homework!",this.ID);
                }
                else
                { 
                    Console.WriteLine("No homework!");
                    return;
                }
                   
                for (int i = 0; i < 3; i++)
                { 
                    Console.WriteLine("Student {0} doing homework {1} hour(s)", this.ID, i);
                    Thread.Sleep(1000);
                }
    
                sender.count++;
            }
    
            public void DontWork(object sender, NofityEventArgs e)
            { 
            	Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} dont work!!!",this.ID);
            }
        }
    }

Program.cs

运行效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 5]  
而为了与我们所使用的C\#框架能够一致，通常会再做一些如下面这样的修改。  
1、让我们的事件参数类型继承C\#框架中的事件参数。

public class NofityEventArgs:System.EventArgs        //事件参数，也就是老师布置作业的内容，做什么作业
    { 
        public bool math = false;
        public bool chinese = true;
    }

2、使用C\#框架中内置的EventHandler委托类型。  
Teacher.cs

public class Teacher
    { 
        //添加event关键字后悔禁止委托字段使用赋值操作符，并且只有包容类Teacher才能调用它
        //public event doHomeWorkEventHandler doHomeWork; 
    
        public event EventHandler doHomeWork;
        public int count;   //用于记录有多少学生做作业了
        public void Notify()    //发布通知
        { 
            NofityEventArgs e = new Event.NofityEventArgs();
            this.doHomeWork.Invoke(this,e);   //开始传递消息，将发布者本身和消息内容传递给订阅者
        }
    }
    
    //public delegate void doHomeWorkEventHandler(Teacher sender,NofityEventArgs e); //创建一个委托类型

Student.cs

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading;
    
    namespace Event
    { 
        class Student
        { 
            public int ID {  get; set; }
    
            public ConsoleColor PenColor {  get; set; }
    
            public void DoHomeWork(object sender,EventArgs e)
            { 
                Console.ForegroundColor = this.PenColor;
                NofityEventArgs message = e as NofityEventArgs;
                Teacher teacher = sender as Teacher;
                if (message.chinese)
                { 
                    Console.WriteLine("Student {0} begin to do Chinese homework!",this.ID);
                }
                else if (message.math)
                { 
                    Console.WriteLine("Student {0} begin to do Math homework!",this.ID);
                }
                else
                { 
                    Console.WriteLine("No homework!");
                    return;
                }
                   
                for (int i = 0; i < 3; i++)
                { 
                    Console.WriteLine("Student {0} doing homework {1} hour(s)", this.ID, i);
                    Thread.Sleep(1000);
                }
    
                teacher.count++;
            }
    
            public void DontWork(object sender, EventArgs e)
            { 
                Console.ForegroundColor = this.PenColor;
                Console.WriteLine("Student {0} dont work!!!",this.ID);
            }
        }
    }

这是因为EventHandler委托类型和我们自定义的类型是一样的(都是两个参数，一个发布者，一个事件消息)，而且由于这种用于事件的委托类型形式比较单一，所以一般我们使用内置的EventHandler就可以了，这也是为了与框架内的事件类型保持一致。

//EventHandler的声明，框架内置的用于事件的委托类型
    using System.Runtime.InteropServices;
    
    namespace System
    { 
        [ComVisible(true)]
        public delegate void EventHandler(object sender, EventArgs e);
    }

直到这里，事件的全部面貌就已经完全呈现在了我们的面前了。

> 总结一下就是，事件本质上就是委托字段的一个封装器，它封装了委托的订阅过程和发布过程。它在避免了编程人员使用委托而发生错误的同时("=")，还保证了委托只能在包含它的类的内部才能被直接调用。事件的这一系列操作，说的简单一点就是：让真正的委托字段成为私有访问字段(private)。

> 参考资料：《C\#本质论》《C\# in depth》《C\# 入门详解》视频

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70]: /images/20230528/9553646d834d4fa9ae2645183b2d7459.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/8386d09e688f43ad9dd3231138a88fb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/96a4d81282cf45cba60a7c5b5f39c095.png
[20200414173808229.png]: /images/20230528/f0bdc6d9937b42aeb09f70e9ddaa6cab.png
[20200414213602789.png]: /images/20230528/bb526c468b314e5cbe842538c31d7ba6.png
[20200414214707989.png]: /images/20230528/a60b2ede770340dfb61d4f9967c3ab3e.png
[20200415081549151.png]: /images/20230528/3eed24c5075048919a778b48d025b7fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/4740703cd2254155b94f73bcc92ac1a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 4]: /images/20230528/f901c48be48a4b63a838a76c7c33f39c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2RheXVoYWl0YW5nMQ_size_16_color_FFFFFF_t_70 5]: /images/20230528/7506918457a14b2ba184c5e00d501cfe.png