EventHandlerList z

写一个类时，有时候会在同一个类上添加很多事件，事件很多的话，是不容易管理的，.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,
        }
    }