熟悉C#中的事件机制,使得我们可以编写出更加贴近于实际情况的程序。
主要内容:
- 本例中事件的场景介绍
- 事件的构造
- 注册/注销事件
- 事件在编译器中的实现
- 显式实现事件
1. 本例中事件的场景介绍
为了更好的介绍事件的机制,首先我们构造一个使用事件的场景(是我以前面试时遇到的一个编程题)。
具体场景大概是这样的:某工厂有个设备,当这个设备的温度达到90摄氏度时,触发警报器报警,同时发送短信通知相关工作人员。
当时我就简单的构造3个类:设备(Equipment),警报器(Alert),短信装置(Message)。
传统的实现方法:
1. 警报器类(Alert)中编写一个报警的方法(StartAlert),短信装置类(Message)中编写一个发短信的方法(SendMessage)
2. 在设备类(Equipment)中编写一个温度90度时调用的方法(SimulateTemperature90)
3. 在设备类(Equipment)中引用警报器类(Alert)和短信装置类(Message)
4. 当温度90度时,SimulateTemperature90中会调用Alert.StartAlert方法和Message.SendMessage方法来完成所需功能
基于事件的实现方法:
1. 警报器类(Alert)中编写一个报警的方法(StartAlert),短信装置类(Message)中编写一个发短信的方法(SendMessage)
2. 在设备类(Equipment)中编写一个温度90度时调用的方法(SimulateTemperature90)
3. 在设备类(Equipment)中编写一个事件(Temperature90)
4. 警报器类(Alert)向设备类(Equipment)注册StartAlert,短信装置类(Message)向设备类(Equipment)注册SendMessage
5. 当温度90度时,SimulateTemperature90会触发事件(Temperature90),
此事件会调用已注册的Alert.StartAlert方法和Message.SendMessage方法来完成所需功能
传统的方法缺陷:
1. 设备类(Equipment)关注警报器类(Alert)和短信装置类(Message),当警报器类(Alert)中的方法变更时,
除了要修改警报器类(Alert),还必须修改设备类(Equipment)中调用警报器类(Alert)中方法的地方
2. 增加功能时,比如增加另一个报警装置(Alert2)时,需要修改设备类(Equipment)中报警的地方
基于事件的实现方法可以很好的改善上述情况:
1. 警报器类(Alert)和短信装置类(Message)关注设备类(Equipment),当警报器类(Alert)中的方法变更时,
只需修改警报器类(Alert)中注册事件的地方,将新的事件注册到设备类(Equipment)的事件(Temperature90)中即可
2. 增加功能时,比如增加另一个报警装置(Alert2)时,将新的报警方法注册到事件(Temperature90)中即可
3. 取消警报器类(Alert)和短信装置类(Message)事件时,只需在相应的类中注销事件就行,无需修改设备类(Equipment)
2. 事件的构造
下面以事件的方法来构造上述应用。
1. 编写事件传递的参数,暂时只包含设备名
2. 定义事件成员
3. 定义触发事件的方法
4. 定义模拟触发事件的方法
代码如下:
// 编写事件传递的参数,暂时只包含设备名
public class EquipmentEventArgs:EventArgs
{
// 设备名
private readonly string equipName;
public string EquipName { get { return equipName; } }
public EquipmentEventArgs(string en)
{
equipName = en;
}
}
public class Equipment
{
// 设备名
private readonly string equipName;
public string EquipName { get { return equipName; } }
public Equipment(string en)
{
equipName = en;
}
// 定义事件成员
public event EventHandler<EquipmentEventArgs> Temperature90;
// 定义触发事件的方法
protected void OnTemperature90(EquipmentEventArgs e)
{
Temperature90(this, e);
}
// 定义模拟触发事件的方法
public void SimulateTemperature90()
{
// 事件参数的初始化
EquipmentEventArgs e = new EquipmentEventArgs(this.EquipName);
// 触发事件
OnTemperature90(e);
}
}
3. 注册/注销事件
定义警报器类(Alert)和短信装置类(Message),并在其中实现注册/注销事件的方法。
代码如下:
// 警报器类
public class Alert
{
// 定义要注册的函数,注意此函数的签名是与 EventHandler<EquipmentEventArgs>一致的
private void StartAlert(Object sender, EquipmentEventArgs e)
{
Console.WriteLine("Equipment: " + e.EquipName + "'s temperature is 90 now!");
}
// 向Equipment注册事件
public void Register(Equipment equip)
{
equip.Temperature90 += StartAlert;
}
// 向Equipment注销事件
public void UnRegister(Equipment equip)
{
equip.Temperature90 -= StartAlert;
}
}
// 短信装置类
public class Message
{
// 定义要注册的函数,注意此函数的签名是与 EventHandler<EquipmentEventArgs>一致的
private void SendMessage(Object sender, EquipmentEventArgs e)
{
Console.WriteLine("Equipment: " + e.EquipName + " sends ‘temperature is 90 now!’ to administrator");
}
// 向Equipment注册事件
public void Register(Equipment equip)
{
equip.Temperature90 += SendMessage;
}
// 向Equipment注销事件
public void UnRegister(Equipment equip)
{
equip.Temperature90 -= SendMessage;
}
}
调用上述事件的代码如下:
class CLRviaCSharp_12
{
static void Main(string[] args)
{
Equipment eq = new Equipment("My Equipment");
Alert alert = new Alert();
Message msg = new Message();
// 注册Alert和Message的事件后
Console.WriteLine("=========注册Alert和Message的事件后=================");
alert.Register(eq);
msg.Register(eq);
eq.SimulateTemperature90();
// 注销Alert的事件后
Console.WriteLine();
Console.WriteLine("=========注销Alert的事件后,只有Message事件==========");
alert.UnRegister(eq);
eq.SimulateTemperature90();
Console.ReadKey(true);
}
}
调用结果如下:
4. 事件在编译器中的实现
在事件的注册/注销时,我们仅仅是简单使用 +=和-=。那么编译其是如何注册/注销事件的呢。
原来编译器在编译时会自动根据我们定义的公共事件(public event EventHandler<EquipmentEventArgs> Temperature90)
生成私有字段Temperature90和事件的add和remove方法。通过ILSpy查看上面编译出的程序集,如下图:
使用 +=和-=时,就是调用编译器生成的add_***和remove_***方法。
下面就是Alert类的Registered和UnRegister方法的IL代码。
事件是引用类型,那么事件在进行注册或者注销时会不会存在线程并发的问题。比如多个线程同时向设备类(Equipment)注册或注销事件时,会不会出现注册或注销不成功的情况呢。
我们进一步观察add_Temperature90的IL代码如下
主要部分就是上图中的红色线框部分,可能有些人不太熟悉IL代码,我将上面的代码翻译成C#大致如下:
public void add_Temperature90(EventHandler<EquipmentEventArgs> value)
{
//[0] class [mscorlib]System.EventHandler`1<class cnblog_bowen.EquipmentEventArgs>
EventHandler<EquipmentEventArgs> args0;
//[1] class [mscorlib]System.EventHandler`1<class cnblog_bowen.EquipmentEventArgs>
EventHandler<EquipmentEventArgs> args1;
//[2] class [mscorlib]System.EventHandler`1<class cnblog_bowen.EquipmentEventArgs>
EventHandler<EquipmentEventArgs> args2;
//[3] bool
bool args3;
// IL_0000 ~ IL_0006
args0 = this.Temperature90;
// IL_0007 ~ IL_002d
do
{
// IL_0007 ~ IL_0008
args1 = args0;
// IL_0009 ~ IL_0015
args2 = (EventHandler<EquipmentEventArgs>)System.Delegate.Combine(args1, value);
// IL_0016 ~ IL_0023
args0 = System.Threading.Interlocked.CompareExchange<EventHandler<EquipmentEventArgs>>(ref this.Temperature90, args2, args1);
// IL_0024 ~ IL_002d
if (args0 != args1)
args3 = true;
else
args3 = false;
}
while (args3);
}
从上面代码可以看出,添加新的事件后(IL_0009 ~ IL_0015),IL会继续验证原有的事件是否被其他线程修改过( IL_0016 ~ IL_0023)
所以我们在注册/注销事件时不用担心线程安全的问题。
5. 显式实现事件
从上面的IL代码,我们看出每个事件都会生成相应的私有字段和相应的add_***和remove_***方法。
对于一个有很多事件的类(比如Windows.Forms.Control)来说,将会生成大量的事件代码,而我们在使用时往往只是使用其中很少的一部分事件。
这样使得在创建这些类的时候浪费大量的内存。为了避免这种现象和高效率的存取事件委托,我们可以构造一个字典来维护大量的事件。
Jeffery Richard在《CLR via C#》中给了我们一个很好的例子,为了以后参考方便,摘抄如下:
using System;
using System.Collections.Generic;
using System.Threading;
// 这个类的目的是在使用EventSet时,提供
// 多一点的类型安全型和代码可维护性
public sealed class EventKey : Object { }
public sealed class EventSet
{
// 私有字典,用于维护 EventKey -> Delegate映射
private readonly Dictionary<EventKey, Delegate> m_events =
new Dictionary<EventKey, Delegate>();
// 添加一个EventKey -> Delegate映射(如果EventKey不存在),
// 或者将一个委托与一个现在EventKey合并
public void Add(EventKey eventKey, Delegate handler)
{
Monitor.Enter(m_events);
Delegate d;
m_events.TryGetValue(eventKey, out d);
m_events[eventKey] = Delegate.Combine(d, handler);
Monitor.Exit(m_events);
}
// 从EventKey(如果它存在)删除一个委托,并且
// 在删除最后一个委托时删除EventKey -> Delegate映射
public void Remove(EventKey eventKey, Delegate handler)
{
Monitor.Enter(m_events);
// 调用TryGetValue,确保在尝试从集合中删除一个不存在的EventKey时,
// 不会抛出一个异常。
Delegate d;
if (m_events.TryGetValue(eventKey, out d))
{
d = Delegate.Remove(d, handler);
// 如果还有委托,就设置新的地址,否则删除EventKey
if (d != null) m_events[eventKey] = d;
else m_events.Remove(eventKey);
}
Monitor.Exit(m_events);
}
// 为指定的EventKey引发事件
public void Raise(EventKey eventKey, Object sender, EventArgs e)
{
// 如果EventKey不在集合中,不抛出一个异常
Delegate d;
Monitor.Enter(m_events);
m_events.TryGetValue(eventKey, out d);
Monitor.Exit(m_events);
if (d != null)
{
// 由于字典可能包含几个不同的委托类型,
// 所以无法在编译时构造一个类型安全的委托调用。
// 因此,我调用System.Delegate类型的DynamicInvoke方法
// 以一个对象数组的形式向它传递回调方法的参数。
// 在内部,DynamicInvoke会向调用的回调方法查证参数的类型安全性,并调用方法。
// 如果存在类型不匹配的情况,DynamicInvoke会抛出一个异常。
d.DynamicInvoke(new Object[] { sender, e });
}
}
}
使用EventSet类的方法也很简单,修改上面的设备类(Equipment)如下:
public class Equipment
{
// 设备名
private readonly string equipName;
public string EquipName { get { return equipName; } }
public Equipment(string en)
{
equipName = en;
}
private readonly EventSet m_events = new EventSet();
// 用于标示事件类型的Key,当有新的事件时,需要再增加一个Key
private static readonly EventKey m_eventkey = new EventKey();
// 注册/注销事件
public event EventHandler<EquipmentEventArgs> Temperature90
{
add { m_events.Add(m_eventkey, value); }
remove { m_events.Remove(m_eventkey, value); }
}
// 定义触发事件的方法
protected void OnTemperature90(EquipmentEventArgs e)
{
m_events.Raise(m_eventkey, this, e);
}
// 定义模拟触发事件的方法
public void SimulateTemperature90()
{
// 事件参数的初始化
EquipmentEventArgs e = new EquipmentEventArgs(this.EquipName);
// 触发事件
OnTemperature90(e);
}
}
其余代码不用修改,编译后可正常运行。
EventSet类是针对事件很多的类来设计的,本例只有一个事件,这样做的优势并不明显。
本文转自wang_yb博客园博客,原文链接:http://www.cnblogs.com/wang_yb/archive/2011/07/11/2103058.html,如需转载请自行联系原作者