Event Manager

mokth

Here is a simple event manager class using .Net delegate and event. Delegation model is a process in which a task is handed over to some other process so as to accomplish it. A manager is assigned a job which could be executed by one of his subordinates. As he knows the exact location of the subordinate, he redirects or delegates the work. Here, manager is the delegate and his subordinate is the method wrapped up with the delegate.

First, create an Interface call IEventManager.

public interface IEventManager
{
    event MyEventHandler eventHandler;
    void fireEvent(object sender, MyEventArgs myEventArgs);
    void performEvent(object sender, MyEventArgs e);
}
Create an Enum class for the event id. Event Id is uses to identify event.

public enum MyEventID
{
      EVENT_TEST1,
      EVENT_TEST2,
      EVENT_TEST3
}
Create a MyEventArgs class which inherit from EventArgs. There are 2 main fields in the class which are a Hashtable and a MyEventId type field. Using Hashtable field rather than a specific type of field has advantage of storing difference type of data in a single hashtable.

public class MyEventArgs : EventArgs
{
   Hashtable _param;
   public Hashtable getParam
   {
      get { return _param; }
      set { _param = value; }
   }
   MyEventID _eventID;
   public MyEventID getEventID
   {
      get { return _eventID; }
      set { _eventID = value; }
   }
   public MyEventArgs(MyEventID eventID, Hashtable param)
   {
      _param = param;
      _eventID = eventID;
   }
  }

Here are the core class, the manager which implemented singleton pattern.

public class MyEventManager : IEventManager
{
   private static MyEventManager _instance;
   public event MyEventHandler eventHandler;
   private static List<IEventManager> listerners = new List<IEventManager>();

   public static MyEventManager Instance
   {
        get { return _instance; }
   }

   //Singleton manager
  static MyEventManager()
  {
      lock (typeof(MyEventManager))
      {
        if (_instance == null)
        {
           _instance = new MyEventManager();
        }
      }
  }
  public MyEventManager()
  {
      eventHandler += new MyEventHandler(performEvent);
  }

  public void fireEvent(object sender, MyEventArgs myEventArgs)
  {
        eventHandler(sender, myEventArgs);
  }

  public void addListener(IEventManager listener)
  {
       listener.eventHandler += new MyEventHandler(listener.performEvent);
       listerners.Add(listener);
  }

public void performEvent(object sender, MyEventArgs e)
{
     for (int i = 0; i < listerners.Count; i++)
     {
       listerners.fireEvent(sender, e);
     }
}
}

Test Class
public
class TestClass1 : IEventManager
{
  #region
IEventManager Members
  public event MyEventHandler eventHandler;
  
public void fireEvent(object sender, MyEventArgs myEventArgs)
  {
      eventHandler(sender, myEventArgs);
  }

  public void performEvent(object sender, MyEventArgs e)
  {
      switch (e.getEventID)
      {
         case MyEventID.EVENT_TEST1:
            Console.WriteLine("Receive event at TestClass1 " +Thread.CurrentThread.ManagedThreadId.ToString());
         break;
      }
   }
   #endregion
}

Test Run
static void Main(string[] args)
{
  TestClass1 t1 = new TestClass1();
  MyEventManager.Instance.addListener(t1);
  MyEventManager.Instance.fireEvent(t1, new MyEventArgs(MyEventID.EVENT_TEST1,  new System.Collections.Hashtable()));
}