C# - Question about Events

Question

I am very new to using C# event handling. Our application has the following events defined:

public sealed class MonitorCallback : IMonitorCallback
{
    public event EventHandler<ApplyEventArgs> ApplyAccepted;
    public event EventHandler<ApplyEventArgs> ApplyRejected;
}

I need to write some code to handle and respond these events when they are fired. Could someone get me started as to how I might do this?

Answer 1

Visual Studio will automatically create stubs for the event handler function when you start typing the += below and hit TAB.

protected MyMonitorCallback MonitorCallback;
public class MyClass
{
     void Main()
     {
          MyMonitorCallback = new MonitorCallback();
          MyMonitorCallback.ApplyAccepted += new EventHander<ApplyEventArgs>(MyMonitorCallback_ApplyAccepted);
     }
     void MyMonitorCallback_ApplyAccepted(object sender, ApplyEventArgs e) {
        ..
     }
}

Answer 2

The best place to start would be the msdn tutorial This will go through declaring, invoking and hooking up an event.

It might also be a good idea to have a read about delegates ( another msdn tutorial ) as you would use them in your event handling and it would be a good idea to get an understanding from the ground up.

Answer 3

When you create the MonitorCallback instance, you subscribe the events to the event handler that you are going to write. Syntax would look something like,

 public class MonitorCallbackFactory{

     public MonitorCallback CreateCallback(){
         //  create the callback instance
         var callback = new MonitorCallback();

         // subscribe the events to the EventHandler.  
         callback.ApplyAccepted += OnApplyAccepted;
         callback.ApplyRejected += OnApplyRejected;

         return callback;
     } 

     protected virtual void OnApplyAccepted(object sender, ApplyEventArgs e){
           // the sender is always the type of object that raises the event, so
           // if you need it strongly typed you can do:
           var callback = (MonitorCallback)sender;
           // then write your code for what happens when
           // the ApplyAccepted event is raised here  
     }

     protected virtual void OnApplyRejected(object sender, ApplyEventArgs e){
           // write your code for what happens when
           // the ApplyRejected event is raised here  
     }

 }

As you can see the += is the syntax to subscribe a handler to an event. -= is the syntax to unsubscribe and event handler.

Answer 4

I presume you already have code like this;

public class EventExample
{
    private EventHandler<ApplyEventArgs> m_evApplyAccepted;
    public event EventHandler<ApplyEventArgs> ApplyAccepted
    {
        add { m_evApplyAccepted += value; }
        remove { m_evApplyAccepted -= value; }
    }
    protected virtual void OnEventName(ApplyEventArgs e)
    {
        if (m_evApplyAccepted != null)
            m_evApplyAccepted.Invoke(this, e);
    }
    public class ApplyEventArgs : EventArgs { }
}

You consume this event like this;

public class EventConsumer
{
    private EventExample eventExample;
    public EventConsumer()
    {
        eventExample = new EventExample();

        //register a handler with the event here
        eventExample.ApplyAccepted += new EventHandler<EventExample.ApplyEventArgs>(eventExample_EventName);
    }

    void eventExample_EventName(object sender, EventExample.ApplyEventArgs e)
    {
        //respond to event here
    }
}