模拟C#的事件添加和删除

从《C# Via CLR》中的演化的一个小demo，探索事件的添加和删除原理，简单明了：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ExpForEvent001
{
    public sealed class EventKey : Object { }

    public sealed class EventSet
    {
        private readonly Dictionary<EventKey, Delegate> m_events = new Dictionary<EventKey, Delegate>();

        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);//Here we used Combine
            Monitor.Exit(m_events);
        }

        public void Remove(EventKey eventKey, Delegate handler)
        {
            Monitor.Enter(m_events);
            Delegate d;
            if (m_events.TryGetValue(eventKey, out d))
            {
                d = Delegate.Remove(d, handler);

                if (d != null) m_events[eventKey] = d;
                else m_events.Remove(eventKey);
            }
            Monitor.Exit(m_events);
        }

        public void Raise(EventKey eventKey, Object sender, EventArgs e)
        {
            Delegate d;
            Monitor.Enter(m_events);
            m_events.TryGetValue(eventKey, out d);
            Monitor.Exit(m_events);

            if (d != null)
            {
                d.DynamicInvoke(new Object[]{ sender, e });
            }
        }
    }

    public class FooEventArgs : EventArgs { }

    public class TypeWithLotsOfEvents
    {
        public readonly EventSet m_eventSet = new EventSet();

        protected EventSet EventSet { get { return m_eventSet; } }

        #region Support Foo Event

        protected static readonly EventKey s_fooEventKey = new EventKey();

        public event EventHandler<FooEventArgs> Foo
        {
            add { m_eventSet.Add(s_fooEventKey, value); }
            remove { m_eventSet.Remove(s_fooEventKey, value); }
        }

        protected virtual void OnFoo(FooEventArgs e)
        {
            m_eventSet.Raise(s_fooEventKey, this, e);
        }

        public void SimulateFoo() { OnFoo(new FooEventArgs()); }

        #endregion
    }

    class Program
    {
        static void Main(string[] args)
        {
            TypeWithLotsOfEvents twle = new TypeWithLotsOfEvents();

            twle.Foo += HandleFooEvent1;
            twle.Foo += HandleFooEvent2;

            twle.SimulateFoo();
        }

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

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

运行结果：

附带Richter大神的一段话：

“JIT编译器能判断代码是否运行在一个Intel Pentium 4 CPU上，并生成相应的本地代码来利用Pentium 4支持的任何【特殊】指令，相反，非托管代码通常是针对通用的、具有最小功能集合的CPU编译的，不会使用提升应用程序性能的特殊指令。”

My words：

不同的体系结构的计算机其指令集是有差别的。软件越抽象则离硬件越远，从而阻挡了我们看到问题实质的视野。