十三、C# 事件
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了十三、C# 事件，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13229字，纯文字阅读大概需要19分钟。
内容图文
1、多播委托
2、事件
3、自定义事件
在上一章中，所有委托都只支持单一回调。
然而，一个委托变量可以引用一系列委托，在这一系列委托中，每个委托都顺序指向一个后续的委托，
从而形成了一个委托链，或者称为多播委托*multicast delegate)。
使用多播委托，可以通过一个方法对象来调用一个方法链，创建变量来引用方法链，并将那些数据类型用
作参数传递给方法。
在C#中，多播委托的实现是一个通用的模式，目的是避免大量的手工编码。这个模式称为
observer(观察者)或者publish-subscribe模式，它要应对的是这样一种情形：你需要将单一事件的通知
(比如对象状态发生的一个变化）广播给多个订阅者(subscriber)。
一、使用多播委托来编码Observer模式
来考虑一个温度控制的例子。
假设：一个加热器和一个冷却器连接到同一个自动调温器。
为了控制加热器和冷却器的打开和关闭，要向它们通知温度的变化。
自动调温器将温度的变化发布给多个订阅者---也就是加热器和冷却器。
1
class
Program
2
{
3
static
void Main(string[] args)
4 {
5//连接发布者和订阅者 6 Thermostat tm = new Thermostat();
7 Cooler cl = new Cooler(40);
8 Heater ht = new Heater(60);
9//设置委托变量关联的方法。+=可以存储多个方法，这些方法称为订阅者。 10 tm.OnTemperatureChange += cl.OnTemperatureChanged;
11 tm.OnTemperatureChange += ht.OnTemperatureChanged;
12string temperature = Console.ReadLine();
13 14//将数据发布给订阅者（本质是依次运行那些方法） 15 tm.OnTemperatureChange(float.Parse(temperature));
16 17 Console.ReadLine();
18 19 20 21 }
22 }
23//两个订阅者类 24class Cooler
25 {
26public Cooler(float temperature)
27 {
28 _Temperature = temperature;
29 }
30privatefloat _Temperature;
31publicfloat Temperature
32 {
33set 34 {
35 _Temperature = value;
36 }
37get 38 {
39return _Temperature;
40 }
41 }
42 43//将来会用作委托变量使用,也称为订阅者方法 44publicvoid OnTemperatureChanged(float newTemperature)
45 {
46if (newTemperature > _Temperature)
47 {
48 Console.WriteLine("Cooler:on ! ");
49 }
50else 51 {
52 Console.WriteLine("Cooler:off ! ");
53 }
54 }
55 }
56class Heater
57 {
58public Heater(float temperature)
59 {
60 _Temperature = temperature;
61 }
62privatefloat _Temperature;
63publicfloat Temperature
64 {
65set 66 {
67 _Temperature = value;
68 }
69get 70 {
71return _Temperature;
72 }
73 }
74publicvoid OnTemperatureChanged(float newTemperature)
75 {
76if (newTemperature < _Temperature)
77 {
78 Console.WriteLine("Heater:on ! ");
79 }
80else 81 {
82 Console.WriteLine("Heater:off ! ");
83 }
84 }
85 }
86 87 88//发布者 89class Thermostat
90 {
91 92//定义一个委托类型 93publicdelegatevoid TemperatureChangeHanlder(float newTemperature);
94//定义一个委托类型变量，用来存储订阅者列表。注：只需一个委托字段就可以存储所有订阅者。 95private TemperatureChangeHanlder _OnTemperatureChange;
96//现在的温度 97privatefloat _CurrentTemperature;
98 99public TemperatureChangeHanlder OnTemperatureChange
100 {
101set { _OnTemperatureChange = value; }
102get { return _OnTemperatureChange; }
103 }
104105106publicfloat CurrentTemperature
107 {
108get { return _CurrentTemperature;}
109set110 {
111if (value != _CurrentTemperature)
112 {
113 _CurrentTemperature = value;
114 }
115 }
116 }
117 }
上述代码使用+=运算符来直接赋值。向其OnTemperatureChange委托注册了两个订阅者。
目前还没有将发布Thermostat类的CurrentTemperature属性每次变化时的值，通过调用委托来
向订阅者通知温度的变化，为此需要修改属性的set语句。
这样以后，每次温度变化都会通知两个订阅者。
public
float
CurrentTemperature
{
get { return _CurrentTemperature; }
set
{
if (value != _CurrentTemperature)
{
_CurrentTemperature = value;
OnTemperatureChange(value);
}
}
}
这里，只需要执行一个调用，即可向多个订阅者发出通知----这天是将委托更明确地
称为“多播委托”的原因。
针对这种以上的写法有几个需要注意的点：
1、在发布事件代码时非常重要的一个步骤：假如当前没有订阅者注册接收通知。
则OnTemperatureChange为空，执行OnTemperatureChange(value)语句会引发一
个NullReferenceException。所以需要检查空值。
public
float
CurrentTemperature
{
get { return _CurrentTemperature; }
set
{
if (value != _CurrentTemperature)
{
_CurrentTemperature = value;
TemperatureChangeHanlder localOnChange = OnTemperatureChange;
if (localOnChange != null)
{
//OnTemperatureChange = null; localOnChange(value);
}
}
}
}
在这里，我们并不是一开始就检查空值，而是首先将OnTemperatureChange赋值给另一个委托变量localOnChange .
这个简单的修改可以确保在检查空值和发送通知之间，假如所有OnTemperatureChange订阅者都被移除（由一个不同的线程），那么不会触发
NullReferenceException异常。
注：将-=运算符应用于委托会返回一个新实例。
对委托OnTemperatureChange-=订阅者，的任何调用都不会从OnTemperatureChange中删除一个委托而使它的委托比之前少一个，相反，
会将一个全新的多播委托指派给它，这不会对原始的多播委托产生任何影响(localOnChange也指向那个原始的多播委托)，只会减少对它的一个引用。
委托是一个引用类型。
2、委托运算符
为了合并Thermostat例子中的两个订阅者，要使用"+="运算符。
这样会获取引一个委托，并将第二个委托添加到委托链中，使一个委托指向下一个委托。
第一个委托的方法被调用之后，它会调用第二个委托。从委托链中删除委托，则要使用"-="运算符。
1
Thermostat.TemperatureChangeHanlder delegate1;
2
Thermostat.TemperatureChangeHanlder delegate2;
3
Thermostat.TemperatureChangeHanlder delegate3;
4 delegate3 = tm.OnTemperatureChange;
5 delegate1 = cl.OnTemperatureChanged;
6 delegate2 = ht.OnTemperatureChanged;
7 delegate3 += delegate1;
8 delegate3 += delegate2;
同理可以使用+ 与 - 。
1
Thermostat.TemperatureChangeHanlder delegate1;
2
Thermostat.TemperatureChangeHanlder delegate2;
3
Thermostat.TemperatureChangeHanlder delegate3;
4 delegate1 = cl.OnTemperatureChanged;
5 delegate2 = ht.OnTemperatureChanged;
6 delegate3 = delegate1 + delegate2;
7 delegate3 = delegate3 - delegate2;
8 tm.OnTemperatureChange = delegate3;
使用赋值运算符，会清除之前的所有订阅者，并允许使用新的订阅者替换它们。
这是委托很容易让人犯错的一个设置。因为本来需要使用"+="运算的时候，很容易就会错误地写成"="
无论是 +、-、 +=、 -=，在内部都是使用静态方法System.Delegate.Combine()和System.Delegate.Remove()来实现的。
3、顺序调用
委托调用顺序图，需要下载。
虽然一个tm.OnTemperatureChange()调用造成每个订阅者都收到通知，但它们仍然是顺序调用的，而不是同时调用，因为
一个委托能指向另一个委托，后者又能指向其它委托。
注：多播委托的内部机制
delegate关键字是派生自System.MulticastDelegate的一个类型的别名。
System.MulticastDelegate则是从System.Delegate派生的，后者由一个对象引用和一个System.Reflection.MethodInfo类型的该批针构成。
创建一个委托时，编译器自动使用System.MulticastDelegate类型而不是System.Delegate类型。
MulticastDelegate类包含一个对象引用和一个方法指针，这和它的Delegate基类是一样的，但除此之外，
它还包含对另一个System.MulticastDelegate对象的引用 。
向一个多播委托添加一个方法时，MulticastDelegate类会创建委托类型的一个新实例，在新实例中为新增的方法存储对象引用和方法指针，
并在委托实例列表中添加新的委托实例作为下一项。
这样的结果就是，MulticastDelegate类维护关由多个Delegate对象构成的一个链表。
调用多播委托时，链表中的委托实例会被顺序调用。通常，委托是按照它们添加时的顺序调用的。
4、错误处理
错误处理凸显了顺序通知的重要性。假如一个订阅者引发一个异常，链中后续订阅不接收不到通知。
为了避免这个问题，使所有订阅者都能收到通知，必须手动遍历订阅者列表，并单独调用它们。
1
public
float
CurrentTemperature
2
{
3
get { return _CurrentTemperature; }
4set 5 {
6if (value != _CurrentTemperature)
7 {
8 9 _CurrentTemperature = value;
10 TemperatureChangeHanlder localOnChange = OnTemperatureChange;
11if (localOnChange != null)
12 {
13foreach (TemperatureChangeHanlder hanlder in localOnChange.GetInvocationList())
14 {
15try16 {
17 hanlder(value);
18 }
19catch (Exception e)
20 {
21 Console.WriteLine(e.Message);
2223 }
24 }
25 }
2627 }
28 }
29 }
5、方法返回值和传引用
在这种情形下，也有必要遍历委托调用列表，而非直接激活一个通知。
因为不同的订阅者返回的值可能不一。所以需要单独获取。
二、事件
目前使用的委托存在两个关键的问题。C#使用关键字event(事件)一解决这些问题。
二、1 事件的作用:
1、封装订阅
如前所述，可以使用赋值运算符将一个委托赋给另一个。但这有可能造成bug。
在本应该使用 "+=" 的位置，使用了"="。为了防止这种错误，就是根本
不为包容类外部的对象提供对赋值运算符的运行。event关键字的目的就是提供额外
的封装，避免你不小心地取消其它订阅者。
2、封装发布
委托和事件的第二个重要区别在于，事件确保只有包容类才能触发一个事件通知。防止在包容
类外部调用发布者发布事件通知。
禁止如以下的代码：
tm.OnTemperatureChange(100);
即使tm的CurrentTemperature没有发生改变，也能调用tm.OnTemperatureChange委托。
所以和订阅者一样，委托的问题在于封装不充分。
二、2 事件的声明
C#用event关键字解决了上述两个问题，虽然看起来像是一个字段修饰符，但event定义的是一个新的成员类型。
1
public
class
Thermostat
2
{
3
private
float
_CurrentTemperature;
4
public
float
CurrentTemperature
5
{
6
set { _CurrentTemperature = value; }
7get { return _CurrentTemperature; }
8 }
9//定义委托类型10publicdelegatevoid TemperatureChangeHandler(object sender, TemperatureArgs newTemperatrue);
1112//定义一个委托变量，并用event修饰，被修饰后有一个新的名字，事件发布者。13publicevent TemperatureChangeHandler OnTemperatureChange = delegate { };
141516publicclass TemperatureArgs : System.EventArgs
17 {
18privatefloat _newTemperature;
19publicfloat NewTemperature
20 {
21set { _newTemperature = value; }
22get { return _newTemperature; }
23 }
24public TemperatureArgs(float newTemperature)
25 {
26 _newTemperature = newTemperature;
27 }
2829 }
30 }
这个新的Thermostat类进行了几处修改:
a、OnTemperatureChange属性被移除了，且被声明为一个public字段
b、在OnTemperatureChange声明为字段的同时，使用了event关键字，这会禁止为一个public委托字段使用赋值运算符。
只有包容类才能调用向所有订阅者发布通知的委托。
以上两点解决了委托普通存在 的两个问题
c、普通委托的另一个不利之处在于，易忘记在调用委托之前检查null值，
通过event关键字提供的封装，可以在声明（或者在构造器中）采用一个替代方案，以上代码赋值了空委托。
当然，如果委托存在被重新赋值为null的任何可能，仍需要进行null值检查。
d、委托类型发生了改变，将原来的单个temperature参数替换成两个新参数。
二、3 编码规范
在以上的代码中，委托声明还发生另一处修改。
为了遵循标准的C#编码规范，修改了TemperatureChangeHandler,将原来的单个temperature参数替换成两新参数，
即sender和temperatureArgs。这一处修改并不是C#编译器强制的。
但是，声明一个打算作为事件来使用的委托时，规范要求你传递这些类型的两个参数。
第一个参数sender就包含"调用委托的那个类"的一个实例。假如一个订阅者方法注册了多个事件，这个参数就尤其有用。
如两个不同的Thermostata实例都订阅了heater.OnTemperatureChanged事件，在这种情况下，任何一个Thermostat实例都
可能触发对heater.OnTemperatureChanged的一个调用，为了判断具体是哪一个Thermostat实例触发了事件，要在Heater.OnTemperatureChanged()
内部利用sender参数进行判断。
第二个参数temperatureArgs属性Thermostat.TemperatureArgs类型。在这里使用嵌套类是恰当的，因为它遵循和OntermperatureChangeHandler委托本身
相同的作用域。
Thermostat.TemperatureArgs，一个重点在于它是从System.EventArgs派生的。System.EventArgs唯一重要的属性是
Empty，它指出不存在事件数据。然而，从System.EventArgs派生出TemperatureArgs时，你添加了一个额外的属性，名为NewTemperature。这样一来
就可以将温度从自动调温器传递到订阅者那里。
编码规范小结：
1、第一个参数sender是object类型的，它包含对调用委托的那个对象的一个引用。
2、第二个参数是System.EventArgs类型的(或者是从System.EventArgs派生，但包含了事件数据的其它类型。）
调用委托的方式和以前几乎完全一样，只是要提供附加的参数。
1
class
Program
2
{
3
static
void Main(string[] args)
4 {
5 Thermostat tm = new Thermostat();
6 7 Cooler cl = new Cooler(40);
8 Heater ht = new Heater(60);
9 10//设置订阅者(方法) 11 tm.OnTemperatureChange += cl.OnTemperatureChanged;
12 tm.OnTemperatureChange += ht.OnTemperatureChanged;
13 14 tm.CurrentTemperature = 100;
15 }
16 }
17//发布者类 18publicclass Thermostat
19 {
20privatefloat _CurrentTemperature;
21publicfloat CurrentTemperature
22 {
23set 24 {
25if (value != _CurrentTemperature)
26 {
27 _CurrentTemperature = value;
28if (OnTemperatureChange != null)
29 {
30 OnTemperatureChange(this, new TemperatureArgs(value));
31 }
32 33 }
34 }
35get { return _CurrentTemperature; }
36 }
37//定义委托类型 38publicdelegatevoid TemperatureChangeHandler(object sender, TemperatureArgs newTemperatrue);
39 40//定义一个委托变量，并用event修饰，被修饰后有一个新的名字，事件发布者。 41publicevent TemperatureChangeHandler OnTemperatureChange = delegate { };
42 43//用来给事件传递的数据类型 44publicclass TemperatureArgs : System.EventArgs
45 {
46privatefloat _newTemperature;
47publicfloat NewTemperature
48 {
49set { _newTemperature = value; }
50get { return _newTemperature; }
51 }
52public TemperatureArgs(float newTemperature)
53 {
54 _newTemperature = newTemperature;
55 }
56 57 }
58 }
59 60//两个订阅者类 61class Cooler
62 {
63public Cooler(float temperature)
64 {
65 _Temperature = temperature;
66 }
67privatefloat _Temperature;
68publicfloat Temperature
69 {
70set 71 {
72 _Temperature = value;
73 }
74get 75 {
76return _Temperature;
77 }
78 }
79 80//将来会用作委托变量使用,也称为订阅者方法 81publicvoid OnTemperatureChanged(object sender, Thermostat.TemperatureArgs newTemperature)
82 {
83if (newTemperature.NewTemperature > _Temperature)
84 {
85 Console.WriteLine("Cooler:on ! ");
86 }
87else 88 {
89 Console.WriteLine("Cooler:off ! ");
90 }
91 }
92 }
93class Heater
94 {
95public Heater(float temperature)
96 {
97 _Temperature = temperature;
98 }
99privatefloat _Temperature;
100publicfloat Temperature
101 {
102set103 {
104 _Temperature = value;
105 }
106get107 {
108return _Temperature;
109 }
110 }
111publicvoid OnTemperatureChanged(object sender, Thermostat.TemperatureArgs newTemperature)
112 {
113if (newTemperature.NewTemperature < _Temperature)
114 {
115 Console.WriteLine("Heater:on ! ");
116 }
117else118 {
119 Console.WriteLine("Heater:off ! ");
120 }
121 }
122 }
通过将sender指定为容器类(this)，因为它是能为事件调用委托的唯一一个类。
在这个例子中，订阅者可以将sender参数强制转型为Thermostat，并以那种方式来访问当前温度，
或通过TemperatureArgs实例来访问在。
然而，Thermostat实例上的当前温度可能由一个不同的线程改变。
在由于状态改变而发生事件的时候，连同新值传递前一个值是一个常见的编程模式，它可以决定哪些状态变化是
允许的。
二、4 泛型和委托
使用泛型，可以在多个位置使用相同的委托数据类型，并在支持多个不同的参数类型的同时保持强类型。
在C#2.0和更高版本需要使用事件的大多数场合中，都无需要声明一个自定义的委托数据类型
System.EventHandler<T> 已经包含在Framework Class Library
注:System.EventHandler<T> 用一个约束来限制T从EventArgs派生。注意是为了向上兼容。
//定义委托类型
public delegate void TemperatureChangeHandler(object sender, TemperatureArgs newTemperatrue);
//定义一个委托变量，并用event修饰，被修饰后有一个新的名字，事件发布者。
public event TemperatureChangeHandler OnTemperatureChange = delegate { };
使用以下泛型代替：
public event EventHandler<TemperatureArgs> OnTemperatureChange = delegate { };
事件的内部机制：
事件是限制外部类只能通过 "+="运算符向发布添加订阅方法，并用"-="运算符取消订阅，除此之外的任何事件都不允许做。
此外，它们还阻止除包容类之外的其他任何类调用事件。
为了达到上述目的，C#编译器会获取带有event修饰符的public委托变量，并将委托声明为private。
除此之外，它还添加了两个方法和两个特殊的事件块。从本质上说，event关键字是编译器用于生成恰当封装逻辑的
一个C#快捷方式。
C#实在现一个属性时，会创建get set，
此处的事件属性使用了 add remove分别使用了Sytem.Delegate.Combine
与 System.Delegate.Remove
1
//
定义委托类型
2
public
delegate
void TemperatureChangeHandler(object sender, TemperatureArgs newTemperatrue);
3 4//定义一个委托变量，并用event修饰，被修饰后有一个新的名字，事件发布者。 5publicevent TemperatureChangeHandler OnTemperatureChange = delegate { };
6 7在编译器的作用下，会自动扩展成：
8private TemperatureChangeHandler _OnTemperatureChange = delegate { };
910publicvoid add_OnTemperatureChange(TemperatureChangeHandler handler)
11 {
12 Delegate.Combine(_OnTemperatureChange, handler);
13 }
14publicvoid remove_OnTemperatureChange(TemperatureChangeHandler handler)
15 {
16 Delegate.Remove(_OnTemperatureChange, handler);
17 }
18publicevent TemperatureChangeHandler OnTemperatureChange
19 {
20 add
21 {
22 add_OnTemperatureChange(value);
23 }
2425 remove
26 {
27 remove_OnTemperatureChange(value);
28 }
2930 }
这两个方法add_OnTemperatureChange与remove_OnTemperatureChange 分别负责实现
"+="和"-="赋值运算符。
在最终的CIL代码中，仍然保留了event关键字。
换言之，事件是CIL代码能够显式识别的一样东西，它并非只是一个C#构造。
二、5 自定义事件实现
编译器为"+="和"-="生成的代码是可以自定义的。
例如，将OnTemperatureChange委托的作用域改成protected而不是private。这样一来，从Thermostat派生的类就被允许直接访问委托，
而无需受到和外部类一样的限制。为此，可以允许添加定制的add 和 remove块。
1
protected TemperatureChangeHandler _OnTemperatureChange = delegate { };
2 3publicevent TemperatureChangeHandler OnTemperatureChange
4 {
5 add
6 {
7//此处代码可以自定义 8 Delegate.Combine(_OnTemperatureChange, value);
910 }
1112 remove
13 {
14//此处代码可以自定义15 Delegate.Remove(_OnTemperatureChange, value);
16 }
1718 }
以后继承这个类的子类，就可以重写这个属性了。
实现自定义事件。
小结：通常，方法指针是唯一需要在事件上下文的外部乃至委托变量情况。
换句话说：由于事件提供了额外的封装特性，而且允许你在必要时对实现进行自定义，所以最佳
做法就是始终为Observer模式使用事件。
原文：http://www.cnblogs.com/tlxxm/p/4663160.html
内容总结
以上是互联网集市为您收集整理的十三、C# 事件全部内容，希望文章能够帮你解决十三、C# 事件所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】