用 C# 做组件设计时的事件实现方法讨论

事件，其实就是将物体的某个过程处理通过委托(delegate, 也就是函数指针) 的方式公开给外部的自定义函数处理。 C# 可以使用多播委托，但实际上一般情况下只需要用到单播。

事件需要通过调用到那个委托的代码触发才可以被调用。
以下用例子来说明。首先我们定义一个委托：

namespace EventDemo
{
    public delegate void ProcessHandler(object sender);
}

最简单的事件定义方式：

namespace EventDemo
{
    public class Class1
    {
        private event ProcessHandler _processHandler = null;
        public event ProcessHandler ProcessStart
        {
            add { _processHandler += value; }
            remove { _processHandler -= value; }
        }
        /// 

        /// 触发事件的某个方法
        /// 
        public void Process()
        {
            _processHandler(this);
            for (int i = 0; i < 10; i++)
                i = i + 1;
        }
        public Class1()
        {
        }
    }
}

Class1 使用原始的事件定义方式, 有一个问题，如果事件非常多的时候，每一个事件都要对应一个相应的私有的委托成员（函数指针）。在窗口程序里尤其可怕，因为 Windows 窗口消息数以千计。这样会造成很庞大的内存消耗。
这个模式需要改进为 Class2。代码如下：

namespace EventDemo
{
    using System.Collections;
    public class Class2
    {
        private Hashtable _eventList = new Hashtable();
        // 每一种事件会对应一个相应的静态变量作为他们在 Hashtable 中的 keys.
        private static object _processStart = new object();
        private static object _processEnd = new object();
        public event ProcessHandler ProcessStart
        {
            add { _eventList.Add(_processStart, value); }
            remove { _eventList.Remove(_processStart); }
        }
        public event ProcessHandler ProcessEnd
        {
            add { _eventList.Add(_processEnd, value); }
            remove { _eventList.Remove(_processEnd); }
        }
        public void Process()
        {
            ProcessHandler start = (ProcessHandler) _eventList[_processStart];
            ProcessHandler end = (ProcessHandler) _eventList[_processEnd];
            if (start != null)
                start(this);
            for (int i = 0; i < 10; i++)
                i = i + 1;
            if (end != null)
                end(this);
        }
        public Class2()
        {
        }
    }
}

Class2 中，每一种事件定义一个相应的静态变量作为他们在 Hashtable 中的 keys.
Hashtable 作为函数指针的容器，是私有的。
这样实际上是 Lazy Allocate 模式，大大减小了内存的开销。
但该实现也有问题，因为每个 key 只对应一个 value，所以不能支持 multicast 的事件。

在 .net 中，通常继承自 Component 类来实现这种基础架构。代码如下：

namespace EventDemo
{
    using System;
    using System.ComponentModel;
    public class Class3 : Component
    {
        private static object _processStart = new object();
        public event EventHandler ProcessStart
        {
            add { Events.AddHandler(_processStart, value); }
            remove { Events.RemoveHandler(_processStart, value); }
        }
        public void Process()
        {
            EventHandler handler = (EventHandler) Events[_processStart];
            if (handler != null)
                handler(this, null);
        }
        public Class3()
        {
        }
    }
}

Component 类的实现是完整的，支持 Multicast 委托。我们用 Reflector 看一下该类的代码，会看到有一个叫做 EventHandlerList 的类，代码如下：

public sealed class EventHandlerList : IDisposable
{
    // Methods
    public EventHandlerList()
    {
    }
 
    public void AddHandler(object key, Delegate value)
    {
        EventHandlerList.ListEntry entry1 = this.Find(key);
        if (entry1 != null)
        {
            entry1.handler = Delegate.Combine(entry1.handler, value);
        }
        else
        {
            this.head = new EventHandlerList.ListEntry(key, value, this.head);
        }
    }
 
    public void Dispose()
    {
        this.head = null;
    }
     
    private EventHandlerList.ListEntry Find(object key)
    {
        EventHandlerList.ListEntry entry1 = this.head;
        while (entry1 != null)
        {
            if (entry1.key == key)
            {
                break;
            }
            entry1 = entry1.next;
        }
        return entry1;
    }
 
    public void RemoveHandler(object key, Delegate value)
    {
        EventHandlerList.ListEntry entry1 = this.Find(key);
        if (entry1 != null)
        {
            entry1.handler = Delegate.Remove(entry1.handler, value);
        }
    }
    // Properties
    public Delegate this[object key]
    {
        get
        {
            EventHandlerList.ListEntry entry1 = this.Find(key);
            if (entry1 != null)
            {
                return entry1.handler;
            }
            return null;
        }
        set
        {
            EventHandlerList.ListEntry entry1 = this.Find(key);
            if (entry1 != null)
            {
                entry1.handler = value;
            }
            else
            {
                this.head = new EventHandlerList.ListEntry(key, value, this.head);
            }
        }
    }
    // Fields
    private ListEntry head;
    // Nested Types
    private sealed class ListEntry
    {
        // Methods
        public ListEntry(object key, Delegate handler, EventHandlerList.ListEntry next)
        {
            this.next = next;
            this.key = key;
            this.handler = handler;
        }
        // Fields
        internal Delegate handler;
        internal object key;
        internal EventHandlerList.ListEntry next;
    }
}

这个类实现了一个事件的链表数据结构。其中每一个具体的事件是采用 Delegate.Combine(), Delegate.Remove() 方法来添加和删除具体的 delegate. 所以这个的实现和 Class2 的实现相比功能更加完整了。

Component 类的代码是这样的：

[DesignerCategory("Component")]
public class Component : MarshalByRefObject, IComponent, IDisposable
{
    private EventHandlerList events;
    protected EventHandlerList Events
    {
        get
        {
            if (this.events == null)
            {
                this.events = new EventHandlerList();
            }
            return this.events;
        }
    }
    // ...
}

它简单的通过提供 Events 这个属性，让设计者可以自由的实现各种属性。

（注：本文的 Class1 ~ Class3 代码范例来自黄忠成的《深入剖析 asp.net 组件设计》一书。）