Learning hard C#学习笔记——读书笔记 08

呵护朋友

1.什么是事件


在生活中，我们有许多的事件，比如：你的朋友结婚，你就会给他送去祝福，这就是事件之一
你朋友结婚就是事件源，你送祝福就是处理事件对应的行为
事件往往会涉及两角色——事件的发布者和事件的订阅者，当某个事件发生之后，事件的发布者会发布消息，事件的订阅者会接收事件发生的通知，并做出相应的处理


2.使用事件


2.1 定义事件

1. // event关键字 委托类型
2. public event EventHandler birthday

复制代码

事件的定义结构为

1. 访问修饰符 event 委托类型 事件名称

复制代码

注意：

• 修饰符一般定义为public，因为事件订阅者需要对事件进行订阅与取消操作，定义为公共类型可以使得事件对其他类可见
  
• 事件的委托类型，既可以是自定义的委托类型，还可以是.NET类库中预定义的EventHanler
  

2.2 订阅与取消事件


事件的订阅和取消，和我们昨天说到的委托链的取消和链接相同，因为事件的处理其实就是调用委托包装后的方法

1. public class Bridegroom {
3.     // 1.自定义委托
4.     public delegate void EventHandler(string msg);
5.     // 2.自定义事件
6.     public event EventHandler MarryEvent;
8.     // 3.发出事件
9.     public void OnMarringComing(string msg) {
10.         // 4.判断是否绑定了事件处理方法
11.         if (MarryEvent != null) {
12.             // 5.触发事件
13.             MarryEvent(msg);
14.         }
15.     }
17.     public static void Main(string[] args) {
19.         Bridegroom bridegroom = new Bridegroom();
21.         Friend friend1 = new Friend("张三");
22.         Friend friend2 = new Friend("李四");
23.         Friend friend3 = new Friend("王五");
25.         // 添加事件的订阅者
26.         /*
27.             这里是给MarryEvent这个事件，绑定委托链
28.             委托链的增加和减少使用的就是 +、-
29.          */
30.         bridegroom.MarryEvent += new EventHandler(friend1.sendMessage);
31.         bridegroom.MarryEvent += new EventHandler(friend2.sendMessage);
33.         // 发出事件
34.         Console.WriteLine("===============================");
35.         bridegroom.OnMarringComing("朋友们，我结婚了！");
36.    
37.         bridegroom.OnMarringComing("朋友们，我结婚了！");
38.         Console.Read();
39.     }
41. }
43. public class Friend {
45.     private string name;
46.     public string Name { get { return this.name; } set { this.name = value; } }
48.     public Friend(string name)
49.     {
50.         this.name = name;
51.     }
53.     public void sendMessage(string message) {
54.         Console.WriteLine(message);
56.         Console.WriteLine(this.Name+"收到了消息");
57.     }
58. }

复制代码

除了可以使用自定义委托的方式，来定义事件外，还可以使用.NET类库中的预定义的委托类型 EventHandler 来定义事件

1. public class Bridegroom
2. {
4.     // 2.自定义事件
5.     public event EventHandler MarryEvent;
7.     // 3.发出事件
8.     public void OnMarringComing(string msg)
9.     {
10.         // 4.判断是否绑定了事件处理方法
11.         if (MarryEvent != null)
12.         {
13.             Console.WriteLine(msg);
14.             // 5.触发事件
15.             MarryEvent(msg,new EventArgs());
16.         }
17.     }
19.     public static void Main(string[] args)
20.     {
22.         Bridegroom bridegroom = new Bridegroom();
24.         Friend friend1 = new Friend("张三");
25.         Friend friend2 = new Friend("李四");
26.         Friend friend3 = new Friend("王五");
28.         // 添加事件的订阅者
29.         /*
30.             这里是给MarryEvent这个事件，绑定委托链
31.             委托链的增加和减少使用的就是 +、-
32.          */
33.         bridegroom.MarryEvent += new EventHandler(friend1.sendMessage);
34.         bridegroom.MarryEvent += new EventHandler(friend2.sendMessage);
36.         // 发出事件
37.    
38.         bridegroom.OnMarringComing("朋友们，我结婚了！");
39.         Console.WriteLine("===============================");
40.         Console.Read();
41.     }
43. }
45. public class Friend
46. {
48.     private string name;
49.     public string Name { get { return this.name; } set { this.name = value; } }
51.     public Friend(string name)
52.     {
53.         this.name = name;
54.     }
56.     public void sendMessage(object obj,EventArgs args)
57.     {
59.         Console.WriteLine(this.Name + "收到了消息");
60.     }
61. }

复制代码

EventHandler 是 .NET 类库中的预定义的委托类型，用于处理不含事件数据的事件，如果想在事件中包含事件数据，可以通过派生（继承）EventArgs来实现

从EventHandler委托的定义可以看出：

• 委托的返回类型为void，因此实例化委托类型的方法也需要满足这一点
  
• 第一个参数 sender 负责保存对触发事件的对象引用，其类型为object
  
• 第二个参数 e 负责保存事件的数据，EventArgs 类也是 .NET 类库中定义的类，它不保存任何数据
  

2.3 扩展EventArgs类

1. public class MarryArgs : EventArgs {
3.     public string Message;
5.     public MarryArgs(string message)
6.     {
7.         this.Message = message;
8.     }
10. }
12. public class Bridegroom
13. {
15.     public delegate void MarryEventHandler(object obj, MarryArgs e);
16.     // 2.自定义事件
17.     public event MarryEventHandler MarryEvent;
19.     // 3.发出事件
20.     public void OnMarringComing(string msg)
21.     {
22.         // 4.判断是否绑定了事件处理方法
23.         if (MarryEvent != null)
24.         {
25.             // 5.触发事件
26.             MarryEvent(this,new MarryArgs(msg));
27.         }
28.     }
30.     public static void Main(string[] args)
31.     {
33.         Bridegroom bridegroom = new Bridegroom();
35.         Friend friend1 = new Friend("张三");
36.         Friend friend2 = new Friend("李四");
37.         Friend friend3 = new Friend("王五");
39.         // 添加事件的订阅者
40.         /*
41.             这里是给MarryEvent这个事件，绑定委托链
42.             委托链的增加和减少使用的就是 +、-
43.          */
44.         bridegroom.MarryEvent += new MarryEventHandler(friend1.sendMessage);
45.         bridegroom.MarryEvent += new MarryEventHandler(friend2.sendMessage);
47.         // 发出事件
48.    
49.         bridegroom.OnMarringComing("朋友们，我结婚了！");
50.         Console.WriteLine("===============================");
52.         bridegroom.MarryEvent -= new MarryEventHandler(friend2.sendMessage);
53.         bridegroom.MarryEvent += new MarryEventHandler(friend3.sendMessage);
54.         bridegroom.OnMarringComing("朋友们，我结婚了！");
56.         Console.Read();
57.     }
59. }
61. public class Friend
62. {
64.     private string name;
65.     public string Name { get { return this.name; } set { this.name = value; } }
67.     public Friend(string name)
68.     {
69.         this.name = name;
70.     }
72.     public void sendMessage(object obj,MarryArgs args)
73.     {
74.         Console.WriteLine(args.Message);
75.         Console.WriteLine(this.Name + "收到了消息");
76.     }
77. }

复制代码

我们可以通过派生的方式，让EventArgs携带事件数据

事件的本质


从事件的执行过程，我们可以看出，事件定义中包含委托，事件和委托到底有什么关系呢？

1. public class Program {
3.     public delegate void MarryHandler(string msg);
5.     public event MarryHandler OnMarry;
7.     static void Main(string[] args) {
8.         Console.WriteLine("Line");
9.     }
10. }

复制代码

从IL代码中，我们可以看出，MarryHandler委托被编译成一个名为MarryHandler的类，而OnMarry事件则被编译上图的代码
我们查看add_OnMarry方法，我们发现它其实是调用了 Delegate.Combine() 这个方法，Delegate.Combine() 这个方法是将多个委托组合成为了一个多路广播委托

而remove_OnMarry()方法，则是调用了 Delegate.Remove() 这个方法，Delegate.Remove() 这个方法是将委托从多路广播委托中删除
而我们还有个OnMarry的字段定义

我们发现OnMarry字段主要是有一个私有的字段类型为MarryHandler的委托类型

总结：事件的本质，其实就是 C# 中的一个特殊的多路广播委托（我们把链接多个方法的委托称之为多路广播委托），事件默认含有一个委托类型的变量，该变量用于保存对事件处理方法的引用，且该委托类型的变量为私有，只能从定义该时间的类中进行访问

来源:https://www.cnblogs.com/trueasureyuki/archive/2023/07/31/17565469.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！