【C#】事件

internal sealed class NewMailEventArgs : EventArgs {

   private readonly String m_from, m_to, m_subject;

   public NewMailEventArgs(String from, String to, String subject) {
      m_from = from; m_to = to; m_subject = subject;
   }

   public String From { get { return m_from; } }
   public String To { get { return m_to; } }
   public String Subject { get { return m_subject; } }
}

 internal class MailManager
    {
        public event EventHandler<NewMailEventArgs> NewMail;

        protected virtual void OnNewMail(NewMailEventArgs e)
        {
            if (NewMail!=null)
            NewMail(this, e);
        }
    }

  internal class MailManager
    {
        public event EventHandler<NewMailEventArgs> NewMail;

        protected virtual void OnNewMail(NewMailEventArgs e)
        {
            e.Raise(this, ref NewMail);
        }

        public void SimulateNewMail(string from, string to, string subject)
        {
            var e = new NewMailEventArgs(from, to, subject);
            OnNewMail(e);
        }
    }

    public static class EventArgExtensions
    {
        public static void Raise<TEventArgs>(this TEventArgs e, Object sender,
            ref EventHandler<TEventArgs> eventDelegate) where TEventArgs : EventArgs
        {
            EventHandler<TEventArgs> temp = Interlocked.CompareExchange(ref eventDelegate, null, null);

            if (temp != null) temp(sender, e);
        }
    }

        static void Main(string[] args)
        {

            var mail = new MailManager();
            mail.NewMail += mail_NewMail;
            mail.SimulateNewMail("a", "b", "c");
            mail.NewMail -= mail_NewMail;
            Console.ReadKey();
        }

        static void mail_NewMail(object sender, NewMailEventArgs e)
        {
            Console.WriteLine(e.From);
            Console.WriteLine(e.To);
            Console.WriteLine(e.Subject);
        }

public sealed class EventKey : Object {
}


///////////////////////////////////////////////////////////////////////////////


public sealed class EventSet {
   // The private dictionary used to maintain EventKey -> Delegate mappings
   private readonly Dictionary<EventKey, Delegate> m_events =
       new Dictionary<EventKey, Delegate>();

   // Adds an EventKey -> Delegate mapping if it doesn‘t exist or 
   // combines a delegate to an existing EventKey
   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);
      Monitor.Exit(m_events);
   }

   // Removes a delegate from an EventKey (if it exists) and 
   // removes the EventKey -> Delegate mapping the last delegate is removed
   public void Remove(EventKey eventKey, Delegate handler) {
      Monitor.Enter(m_events);
      // Call TryGetValue to ensure that an exception is not thrown if
      // attempting to remove a delegate from an EventKey not in the set
      Delegate d;
      if (m_events.TryGetValue(eventKey, out d)) {
         d = Delegate.Remove(d, handler);

         // If a delegate remains, set the new head else remove the EventKey
         if (d != null) m_events[eventKey] = d;
         else m_events.Remove(eventKey);
      }
      Monitor.Exit(m_events);
   }

   // Raises the event for the indicated EventKey
   public void Raise(EventKey eventKey, Object sender, EventArgs e) {
      // Don‘t throw an exception if the EventKey is not in the set
      Delegate d;
      Monitor.Enter(m_events);
      m_events.TryGetValue(eventKey, out d);
      Monitor.Exit(m_events);

      if (d != null) {
         // Because the dictionary can contain several different delegate types,
         // it is impossible to construct a type-safe call to the delegate at 
         // compile time. So, I call the System.Delegate type’s DynamicInvoke 
         // method, passing it the callback method’s parameters as an array of 
         // objects. Internally, DynamicInvoke will check the type safety of the 
         // parameters with the callback method being called and call the method.
         // If there is a type mismatch, then DynamicInvoke will throw an exception.
         d.DynamicInvoke(new Object[] { sender, e });
      }
   }
}

public class FooEventArgs : EventArgs { }

// Define the EventArgs-derived type for this event.
public class BarEventArgs : EventArgs { }

///////////////////////////////////////////////////////////////////////////////

internal class TypeWithLotsOfEvents {

    // Define a private instance field that references a collection.
    // The collection manages a set of Event/Delegate pairs.
    // NOTE: The EventSet type is not part of the FCL, it is my own type.
    private readonly EventSet m_eventSet = new EventSet();

    // The protected property allows derived types access to the collection.
    protected EventSet EventSet { get { return m_eventSet; } }

    #region Code to support the Foo event (repeat this pattern for additional events)
    // Define the members necessary for the Foo event.
    // 2a. Construct a static, read-only object to identify this event.
    // Each object has its own hash code for looking up this
    // event’s delegate linked list in the object’s collection.
    protected static readonly EventKey s_fooEventKey = new EventKey();

    // 2d. Define the event’s accessor methods that add/remove the
    // delegate from the collection.
    public event EventHandler<FooEventArgs> Foo {
        add { m_eventSet.Add(s_fooEventKey, value); }
        remove { m_eventSet.Remove(s_fooEventKey, value); }
    }

    // 2e. Define the protected, virtual On method for this event.
    protected virtual void OnFoo(FooEventArgs e) {
        m_eventSet.Raise(s_fooEventKey, this, e);
    }

    // 2f. Define the method that translates input to this event.
    public void SimulateFoo() {
        OnFoo(new FooEventArgs());
    }
    #endregion

    #region Code to support the Bar event
    // 3. Define the members necessary for the Bar event.
    // 3a. Construct a static, read-only object to identify this event.
    // Each object has its own hash code for looking up this
    // event’s delegate linked list in the object’s collection.
    protected static readonly EventKey s_barEventKey = new EventKey();

    // 3d. Define the event’s accessor methods that add/remove the
    // delegate from the collection.
    public event EventHandler<BarEventArgs> Bar {
        add { m_eventSet.Add(s_barEventKey, value); }
        remove { m_eventSet.Remove(s_barEventKey, value); }
    }

    // 3e. Define the protected, virtual On method for this event.
    protected virtual void OnBar(BarEventArgs e) {
        m_eventSet.Raise(s_barEventKey, this, e);
    }

    // 3f. Define the method that translates input to this event.
    public void SimulateBar() {
        OnBar(new BarEventArgs());
    }
    #endregion
}