注：本文系学习笔记。
上一篇文章记录了我对C#中委托的理解。委托实际上是一种类型。可以将一个或多个方法绑定到委托上面，调用委托时，一次执行委托上面绑定的方法。本文要讲述的事件实际上和委托有很深的“感情”。还是以上课的例子开始吧，假设距离上课时间前30分钟去教室上课。在距离上课前5分钟，会发生下面两件事：预备上课铃响，电子屏幕上显示上课时间。我们以下面的代码来表示模拟这个过程。
class Lesson{
private int remainTime;//距离上课时间
//课前动作
private void PrepareLesson(){
for(int i=30;i>=0;i--)
{
remainTime=i;
if(i<=5)
{
RingBell(remainTime);
DisplayLesson(remainTime);
}
}
}
//响铃
private void RingBell(int remainTime){
console.WriteLine("叮铃铃，距离上课还有 {0} 分钟，请同学们最好上课准备。",remainTime);
}
//屏幕显示准备上课
private void DisplayLesson(int remainTime){
console.WriteLine("距离上课还有 {0} 分钟。",remainTime);
}
}
class Program{
static void main(){
Lesson lesson=new Lesson();
lesson.PrepareLesson();
}
}
上面的代码很清楚，能够达到我们想要实现的效果。但是这样写并不好，假设学校期中考试期间，为了不打扰考试的考试，要求不能响铃，而考试结束后恢复响铃，这时候我们处理起来就比较麻烦。又或者我们的Lesson这个类表示课前准备工作，是表示上课前30分钟，我们学生完成的一些事情（假设还有其他事情，比如复习上节课内容，预习新知识等等）。把响铃和屏幕显示上课时间放在这个类里就会有点奇怪。根据面向对象原则，我们应该把响铃和屏幕显示单独放在各自的一个类里。代码修改如下：
public class Lesson{
private int remainTime;
private void PrepareLesson(){
for(int i=30;i>=0;i--)
{
remainTime=i;
}
}
}
public class Bell{
private void RingBell(int remainTime){
console.WriteLine("叮铃铃，距离上课还有 {0} 分钟，请同学们最好上课准备。",remainTime);
}
}
public class Display{
private void DisplayLesson(int remainTime){
console.WriteLine("距离上课还有 {0} 分钟。",remainTime);
}
}
这样就可以了，但是现在，如何让在距离上课时间不到5分钟的时候，响铃和屏幕显示准备上课呢。这里用到ObServer设计模式。这里简单举个例子说明ObServer设计模式，中国移动有提供每月话费账单、流量账单之类的查询业务。但是并不是每个人都需要它推送这样的消息。有的人可能不需要查询，有的人可能只关心话费账单，有的人可能只关心流量问题，有的人可能两者都需要。那么移动公司具体是如何为每个人提供他所需要的服务呢？当然是根据用户订阅的种类，用户关心的什么，就发送什么。Observer设计模式与此类似，它包含两类对象。
- Subject：监视对象，它包含着其他对象所感兴趣的内容。在本范例中，上课就是一个监视对象，它包含的其他对象所感兴趣的内容，就是remainTime字段，当这个字段的值小于等于5时，会不断把数据发给监视它的对象。
- Observer：监视者，它监视Subject，当Subject中的某件事发生的时候，会告知Observer，而Observer则会采取相应的行动。在本范例中，Observer有铃铛和屏幕显示器，它们采取的行动分别是响铃和显示上课准备。
Observer设计模式：Observer设计模式是为了定义对象间的一种一对多的依赖关系，以便于当一个对象的状态改变时，其他依赖于它的对象会被自动告知并更新。Observer模式是一种松耦合的设计模式。
下面继续修改代码
上例可见，事件实际上就是一个委托。
public class Lesson{
private int remainTime;
public delegate void PrepareHandler(int remainTime);
public event PrepareHandler PrepareEvent;
private void PrepareLesson(){
for(int i=30;i>=0;i--)
{
remainTime=i;
if(i<=5)
{
if(PrepareEvent!=null)
{
PrepareEvent(remainTime);
}
}
}
}
}
public class Bell{
private void RingBell(int remainTime){
console.WriteLine("叮铃铃，距离上课还有 {0} 分钟，请同学们最好上课准备。",remainTime);
}
}
public class Display{
private static void DisplayLesson(int remainTime){
console.WriteLine("距离上课还有 {0} 分钟。",remainTime);
}
}
class Program{
static void main(){
Lesson lesson=new Lesson();
lesson.PrepareEvent+=(new Bell()).RingBell;
lesson.PrepareEvent+=Display.DisplayLesson;
lesson.PrepareLesson();
}
}
那么事件跟委托有什么区别呢，上篇文章介绍了，委托必须初始化之后才能添加绑定的方法，而上面的代码我们可以看到直接给事件添加绑定方法。这是因为事件是一个封装了的委托，.NET框架实际上在编译的时候已经为时间做了初始化。上面事件的用法与我们见到的.NET中的事件形式上不同，实际上.NET Framework中的事件模型是规范化了的，.NET事件的编码规范如下
- 委托类型的名称都应该以EventHandler结束。
- 委托的原型定义：有一个void返回值，并接受两个输入参数：一个Object 类型，一个 EventArgs类型(或继承自EventArgs)。
- 事件的命名为 委托去掉 EventHandler之后剩余的部分。
- 继承自EventArgs的类型应该以EventArgs结尾。
那么我们继续修改我们的代码，让它遵循规范
class Lesson{
private int remainTime;
public delegate void PrepareEventHandler(Object sender,PrepareEventArgs e);
public Event PrepareEventHandler Prepare;
public class PrepareEventArgs:EventArgs{
public readonly int remainTime;
public PrepareEventArgs(int remainTime){
this.remainTime=remainTime;
}
}
protected virtual void OnPrepare(PrepareEventArgs e){
if (Prepare!=null)
{
Prepare(this,e)
}
}
public void PrepareLesson(){
for(int i=30;i>=0;i--)
{
remainTime=i;
if(remainTime<=5)
{
PrepareEventArgs e=new PrepareEventArgs(remainTime);
OnPrepare(e)
}
}
}
public class Bell{
public void RingBell(Object sender,Lesson.PrepareEventArgs e){
Lesson lesson=(Lesson)sender;
console.WriteLine("叮铃铃，距离上课还有 {0} 分钟，请同学们最好上课准备。",e.remainTime);
}
}
public class Display{
public static void DisplayLesson(Object sender,Lesson.PrepareEventArgs e){
Lesson lesson=(Lesson)sender;
console.WriteLine("距离上课还有 {0} 分钟。",e.remainTime);
}
}
class Program{
static void main(){
Lesson lesson=new Lesson();
Bell bell=new Bell();
lesson.Prepare+=bell.RingBell;
lesson.Prepare+=Display.DiaplayLesson;
lesson.PrepareLesson();
}
}
最后总结一下：C#中的事件处理实际上是一种具有特殊签名的delegate，它是将委托进行封装，不允许直接方位委托本身，只能通过给委托添加和移除绑定的方法。(+=、-=实际上是调用了add 和 remove方法)像下面这个样子：
public delegate void MyEventHandler(object sender, MyEventArgs e);
其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。
就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：
- 定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。
- 定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。
- 定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。
- 用event关键字定义事件对象，它同时也是一个delegate对象。
- 用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。
- 需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。
- 适当的地方调用事件触发方法触发事件。