[CLR via C#]11. 事件

 // 1. 一个被初始化为null的私有委托字段
  private EventHandler<NewMailEventArgs> NewMail= null;
 
  //2. 一个公共add_Xxx方法(其中Xxx是事件名)
  //允许方法登记对事件的关注
  public void add_NewMail(EventHandler<NewMailEventArgs> value)
{
    //通过循环对CompareExchange的调用
    //可以以一种线程安全的方式向事件添加委托
    EventHandler<NewMailEventArgs> handler2;
    EventHandler<NewMailEventArgs> newMail = this.NewMail;
    do
    {
        handler2 = newMail;
        EventHandler<NewMailEventArgs> handler3 = (EventHandler<NewMailEventArgs>) Delegate.Combine(handler2, value);
        newMail = Interlocked.CompareExchange<EventHandler<NewMailEventArgs>>(ref this.NewMail, handler3, handler2);
    }
    while (newMail != handler2);
}
 
//3. 一个公共remove_Xxx方法(其中Xxx是事件名)
//允许方法注销对事件的关注
public void remove_NewMail(EventHandler<NewMailEventArgs> value)
{
    //通过循环对CompareExchange的调用
    //可以以一种线程安全的方式向事件移除委托
    EventHandler<NewMailEventArgs> handler2;
    EventHandler<NewMailEventArgs> newMail = this.NewMail;
    do
    {
        handler2 = newMail;
        EventHandler<NewMailEventArgs> handler3 = (EventHandler<NewMailEventArgs>) Delegate.Remove(handler2, value);
        newMail = Interlocked.CompareExchange<EventHandler<NewMailEventArgs>>(ref this.NewMail, handler3, handler2);
    }
    while (newMail != handler2);
}

/// <summary>
/// 这个类目的是在使用EventSet时，提供多一点的类型安全性和代码可维护性
/// </summary>
public sealed class EventKey : Object
{
}
 
/// <summary>
/// 代表一个集合，其中包括了事件以及事件的委托列表
/// </summary>
public sealed class EventSet
{
    /// <summary>
    /// 私有字典，用于维护EventKey -> Delagate 映射
    /// </summary>
    private readonly Dictionary<EventKey, Delegate> m_events =
        new Dictionary<EventKey, Delegate>();
 
    /// <summary>
    /// 添加一个 EventKey -> Delegate 映射 (如果EventKey不存在)
    /// 或者将一个委托与一个现有的EventKey合并
    /// </summary>
    /// <param name="eventKey"></param>
    /// <param name="handler"></param>
    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);
    }
 
    /// <summary>
    /// 从EventKey(如果存在)删除一个委托，并且
    /// 再删除最后一个委托时删除EventKey -> Delegate 映射
    /// </summary>
    /// <param name="eventKey"></param>
    /// <param name="handler"></param>
    public void Remove(EventKey eventKey, Delegate handler)
    {
        Monitor.Enter(m_events);
        // 调用TryGetValue,确保在尝试从集合中删除一个不存在的EvenrKey时，
        // 不会抛出异常
        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);
    }
 
    /// <summary>
    /// 为指定的EventKey -> Delegate 映射引发事件
    /// </summary>
    /// <param name="eventKey"></param>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    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会向调用的回调方法查证参数的
            // 类型安全性，并调用方法。
            // 如果存在类型不匹配情况，则抛出异常
            d.DynamicInvoke(new Object[] { sender, e });
        }
    }
}

using System;

// 为这个事件定义从EventArgs派生的类型
public class FooEventArgs : EventArgs { }

internal class TypeWithLotsOfEvents {

    // 定义一个虚实例字段，它引用一个集合
    // 集合用来管理一组"事件/委托"对
    // 注意: EnentSet类型不是FCl一部分，它是我们自己定义的类型
    private readonly EventSet m_eventSet = new EventSet();

    // protected属性使派生类型能访问集合
    protected EventSet EventSet { get { return m_eventSet; } }

    #region 用于支持Foo事件的代码 (为附加的事件重复这个模式)
    // 定义Foo事件必要的成员
    // 2a. 构造一个静态只读对象来标识这个事件
    // 每个对象都有它自己的哈希码，以便在对象的集合中查找这个事件的委托链表
    protected static readonly EventKey s_fooEventKey = new EventKey();

    // 2d. 定义事件的访问器方法，用于在集合中增删委托
    public event EventHandler<FooEventArgs> Foo {
        add { m_eventSet.Add(s_fooEventKey, value); }
        remove { m_eventSet.Remove(s_fooEventKey, value); }
    }

    // 2e. 为这个事件定义受保护的虚方法OnFoo
    protected virtual void OnFoo(FooEventArgs e) {
        m_eventSet.Raise(s_fooEventKey, this, e);
    }

    // 2f. 定义将输入转换成为这个事件的方法
    public void SimulateFoo() {
        OnFoo(new FooEventArgs());
    }
    #endregion
}

public static void Main() {
       TypeWithLotsOfEvents twle = new TypeWithLotsOfEvents();

       // 添加一个回调
       twle.Foo += HandleFooEvent;

       twle.SimulateFoo();
   }

   private static void HandleFooEvent(object sender, FooEventArgs e)
   {
       Console.WriteLine("Handling Foo Event here...");
   }