C# 事件浅析

前言

　　对于搞.net的朋友来说，经常会遇到关于事件和委托的问题：事件与委托有什么关系？事件的本质是什么？委托的本质又是什么？由于.net 做了大量的封装，对于初学者，这两个概念确实不怎么好理解。事件是用户与应用程序交互的基础，它是回调机制的一种应用。举个例子，当用户点击按钮时，我们希望弹出一句“您好”；这里的【点击】就是一个事件；那么回调就是我们注册一个方法，当用户点击时，程序自动执行这个方法去响应这个操作，而不是我们时刻去监听用户有没有点击。

　　上一篇已经介绍了委托的相关知识，它就是.net用来实现回调机制的技术，而事件又是回调机制的一种应用，在学习事件前，应该先学习好委托的知识。有了委托的基础，接下来就让我们一步步走进事件。

一、使用事件

　　假设场景：有一个邮件管理员（事件拥有者），它赋值接收邮件，当邮件到来时（事件），邮件可以交给传真员和打印员处理（事件订阅者）。很明显，邮件到来的时间只有邮件管理员知道，传真员和打印员也不可能时刻去询问有没有新邮件，而是应该由管理员主动来通知（回调），但他们也要先告诉管理员，新邮件到来时，我需要处理（订阅）。这里接收新邮件就是一个事件，邮件有一定的信息（事件附加信息），例如：发送人、接收人，内容。接下来我们通过这个过程来了解事件。

　　1. 定义事件所需要的附加信息

　　按照约定，所有的事件的附加信息都应该从EventArgs派生，因为我们希望一看就知道这是个事件附加信息参数，而不是其它的。EventArgs的定义如下：

public class EventArgs {
    public static readonly EventArgs Empty = new EventArgs();
    public EventArgs() {}
}

可以看到，该类有一个静态只读字段Empty，这是一个单例；与String.Empty一样，当我们需要一个空的EventArgs时，应该使用EventArgs.Empty，而不是重新去new一个。

　　我们定义一个NewMailEventArgs参数，如下：

class NewMailEventArgs : EventArgs
{
    private string from;
    private string to;
    private string content;

    public string From { get { return from; } }
    public string To { get { return to; } }
    public string Content { get { return content; } }

    public NewMailEventArgs(string from,string to,string content)
    {
        this.from = from;
        this.to = to;
        this.content = content;
    }
}

2. 定义事件

　　c#里定义事件用到了event关键字，而且事件一般都是公开类型的。我们定义一个NewMail事件如下：

public event EventHandler<NewMailEventArgs> NewMail;

我们说NewMail是一个事件，但.net并没有事件这种类型。实际上，这里它是一个EventHandler<TEventArgs>委托（委托又是引用类型），只不过用了event进行修饰，也可以说它是一种具有事件性质的委托。

　　我们知道委托是用来包装回调函数的，它的本质是一个class，回调函数的签名必须与委托的签名一致。一个事件可以有多个处理函数，一个函数就会被包装成一个委托对象，所有的委托对象都保存在NewMail的委托链当中。所以，触发NewMail事件，其实就是遍历其指向的委托对象的委托链，执行每个委托对象所包装的方法。(不清楚可以看委托)

　　EventHandler 是个泛型委托，他的定义如下：

public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e);

　这里有两个特点：1. 返回值是void，这是因为事件处理函数一般不需要有返回值，.net中大部分的事件处理函数都是没有返回值的。2. object类型的sender参数，这表示事件的拥有者；这也很符合逻辑，我们除了要拿到实际的附加信息外，还要知道事件是从哪里来的；至于为什么是object类型的，是因为这样可以给更多的类型使用。

　　3. 定义事件触发函数　　

//3.定义触发事件的方法
protected virtual void OnNewMail(NewMailEventArgs e)
{
    /* 第1种做法
     if(this.NewMail != null)
     {
        this.NewMail(this,e);
     }
     */

    /* 第二种做法
    EventHandler<NewMailEventArgs> temp = this.NewMail;
    if (temp != null)
    {
        temp(this, e);
    }
    */

    //第三种做法
    EventHandler<NewMailEventArgs> temp = Interlocked.CompareExchange(ref this.NewMail, null, null);
    if (temp != null)
    {
        temp(this, e);
    }
}

第一种做法是很常见的做法，判断不为空，然后就触发。CLR里提到这是线程不安全的做法，因为单我们判断不为空后，准备执行时，另一个线程将从委托链将委托移除，此时变成了空，引发NullReferenceException异常。第二、三种做法都是线程安全的，因为它通过一个临时委托变量（委托链保存了所有委托），通过上一篇对委托链的了解，我们知道对委托链进行Combine/Remove实际都会创建一个新的数组对象，此时对temp没有影响。但实际上事件主要在单线程的环境下使用，所以一般也不会出现这种问题。

　　4. 包装好事件参数，调用事件触发函数。

public void ReceiveNewMail(string from, string to, string content)
{
    NewMailEventArgs e = new NewMailEventArgs(from, to, content);
    OnNewMail(e);
}

接下来，对该事件感兴趣的，就可以对该事件进行注册。

class Fax
{
    public Fax(MailManager mm)
    {
        mm.NewMail += FaxMsg;
    }

    private void FaxMsg(object sender, NewMailEventArgs e)
    {
        Console.WriteLine(string.Format("fax receive，from:{0} to:{1} content is:{2}", e.From, e.To, e.Content));
    }
}

二、事件揭秘

　　前面我们已经提到事件的本质是委托，或者说是委托的一种应用。要深入理解事件，我们通过ILDasm.exe查到定义事件而生成的代码。

public event EventHandler<NewMailEventArgs> NewMail;  

可以看到当我们定义一个NewEvent时，编译器帮我们生成了：1. 一个private NewMail 字段，类型为 EventHandler<NewMailEventArgs>。 2.一个 add_NewMail 方法，用于将委托添加到委托链（内部调用了Delegate.Combine方法）。3.一个 remove_NewMail 方法，用于将委托从委托链移除（内部调用了Delegate.Remove方法）。对事件的操作，就是是对NewMail字段的操作。

　　现在我们知道了，事件的本质就是委托，定义事件就是定义委托。只不过编译器隐藏了这个过程。那为什么不直接使用委托呢？

三、为什么不直接用委托

　　我们知道，事件的本质是委托，那用事件实现的地方，用委托也完成可以实现。上面的代码，我们完全可能这样写来达到相同的目的：

class MailManager
{
    public EventHandler<EventArgs> NewMail;       

    public void RaiseNewMail()
    {
        if (NewMail != null)
        {
            NewMail(this, EventArgs.Empty);
        }
    }
}

外部调用：

class Fax
{
    public Fax(MailManager mm)
    {
        mm.NewMail += FaxNewMail;
    }

    public void FaxNewMail(object sender, EventArgs e)
    {
        Console.WriteLine("Fax New Mail 处理成功");
    }
}

对于维护对象状态的字段我们往往不设计为公开类型，因为外部完全可以随意改变它，这不是我们想看到的。例如上面那样写，我们可以在外部直接就调用NewMail的Invoke方法。而且对于字段，我们无法控制具体的获取和设置过程，要控制就需要定义一个Get_ 方法，一个Set_方法，对于委托类型来说，就是Add_和Remove_。对于每个事件，都去定义Add_/Remove_是非常麻烦的。说到这里我们会马上连想到属性的设计，没错，属性是用Get_/Set_方法提供访问私有字段（非委托）的方法，事件就是用Add_/Remove_方法提供访问私有委托字段的方法。

四、显示实现事件

　　我们知道隐式实现属性时，编译器会为我们生成一个private的字段，例如：public string Name{get;set;} 会自动生成一个 _name字段。但是我们显示实现时，编译器就不会为生成了。例如下面的写法：

public string Name
{
    get{return "Tom";}
    set{}
}

对于事件来说显示实现就是：

private EventHandler<NewMailEventArgs> _newMail;
public event EventHandler<NewMailEventArgs> NewMail
{
    add
    {
        _newMail += value;
    }
    remove
    {
        _newMail -= value;
    }
}

Control 的 EventHandlerList

　　对于 Control 来说，它定义了大量的事件（定义事件就是定义委托），而这些事件不一定都会用到，所以这会浪费大量的内存。所以 Control 里的事件都是显示实现的，并且将委托保存在一个EventHandlerList集合中，这是一个key-value的集合。这样需要处理哪些事件就只要添加相应的委托即可，看起来像是这样的：

class Control
{
    private EventHandlerList events;
    protected EventHandlerList Events
    {
        get
        {
            if (this.events == null)
            {
                this.events = new EventHandlerList();
            }
            return this.events;
        }
    }

    private static readonly object _clickEventObj = new object();
    private static readonly object _mouseOverEventObj = new object();       

    public event EventHandler<EventArgs> Click
    {
        add
        {
            this.Events.AddHandler(_clickEventObj, value);
        }
        remove
        {
            this.Events.RemoveHandler(_clickEventObj, value);
        }
    }

    public event EventHandler<EventArgs> MouseOver
    {
        add
        {
            this.Events.AddHandler(_mouseOverEventObj, value);
        }
        remove
        {
            this.Events.RemoveHandler(_mouseOverEventObj, value);
        }
    }
}

也就是我们针对每个事件定义一个 object 类型作为集合的key，虽然会定义许多object，但object的代价比委托的要小很多。

　　至此我们应该知道：委托的本质是引用类型，用于包装回调函数，委托用于实现回调机制；事件的本质是委托，事件是回调机制的一种应用。　　

以上动图由“图斗罗”提供