类型安全的EventHandlerList

我们写一个类时，有时候会在同一个类上添加很多事件，事件很多的话，是不容易管理的，.NET提供的EventHandlerList可以辅助多个事件的管理，但不方便的地方是，它不是类型安全的,缺少类型安全，多少用起来担心会出错。经过我的一番改造，可以将系统提供的EventHandlerList通过泛型提供类型安全的管理。泛型类EventHandlerList.cs的实现如下：

 public sealed class EventHandlerList<T> : IDisposable
     {
         ListEntry head;

         public EventHandlerList()
         { }

         public Delegate this[T key]
         {
             get{
                 ListEntry e = Find(key);
                 return e == null ? null : e.m_handler;
             }
             set{
                 ListEntry e = Find(key);
                 if (e != null){
                     e.m_handler = value;
                 }
                 else {
                     head = new ListEntry(key, value, head);
                 }
             }
         }

         public void AddHandler(T key, Delegate value)
         {
             ListEntry e = Find(key);
             if (e != null) {
                 e.m_handler = Delegate.Combine(e.m_handler, value);
             }
             else {
                 head = new ListEntry(key, value, head);
             }
         } 

         public void AddHandlers(EventHandlerList<T> listToAddFrom)
         {
             ListEntry currentListEntry = listToAddFrom.head;
             while (currentListEntry != null) {
                 AddHandler(currentListEntry.m_key, currentListEntry.m_handler);
                 currentListEntry = currentListEntry.m_next;
             }
         }

         public void Dispose()
         {
             head = null;
         } 

         private ListEntry Find(T key)
         {
             ListEntry found = head;
             while (found != null) {
                 if (found.m_key.Equals(key)) {
                     break;
                 }
                 found = found.m_next;
             }
             return found;
         }

         public void RemoveHandler(T key, Delegate value)
         {
             ListEntry e = Find(key);
             if (e != null) {
                 e.m_handler = Delegate.Remove(e.m_handler, value);
             }
         }

         private sealed class ListEntry
         {
             internal ListEntry m_next;
             internal T m_key;
             internal Delegate m_handler;

             public ListEntry(T key, Delegate handler, ListEntry next)
             {
                 m_next = next;
                 m_key = key;
                 m_handler = handler;
             }
         }
     }

有了它，我们就可以改变多个事件的使用方式，例子类似于下面这个。

 public class DispatcherCore
     {
         readonly EventHandlerList<EventType> Events = new EventHandlerList<EventType>();

         public event EventHandler OnReceiveData {
             add {
                 Events.AddHandler(EventType.ReceiveData, value);
             }
             remove {
                 Events.RemoveHandler(EventType.ReceiveData, value);
             }
         }

         public event EventHandler OnRefreshData
         {
             add{
                 Events.AddHandler(EventType.RefreshData, value);
             }
             remove{
                 Events.RemoveHandler(EventType.RefreshData, value);
             }
         }

         private void RaiseEvent(EventType eventType, EventArgs args)
         {
             var raiseEvent = Events[eventType] as EventHandler;

             if (raiseEvent != null)
                 raiseEvent(this, args);
         }

         // 其它逻辑，在适当的时候调用RaiseEvent

         private enum EventType
         {
             None,
             ReceiveData,
             RefreshData,
             Error,
             Info,
         }
     }

用起来更方便，很难出错。希望对大家有用。