模拟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：

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