Events In C#


Events are members of the class that raises them. When some thing happens a class can raise an event, which have a message that contain informations about the event (event arguments) and send them out to the rest of the application, other parts of the application can respond to the event by excuting methods called event handlers.

Event handler is a method that has the same signature as the event and this method is executed when the event occurs.
To define an event you need first to define a delegate that contains the methods that will be called when the event raised, and then you define the event based on that delegate.

  1. public class MyClass  
  2. {  
  3.     public delegate void MyDelegate(string message);  
  4.     public event MyDelegate MyEvent;  
  5. }  
Raising an events is a simple step. First you check the event agaist a null value to ensure that the caller has registered with the event, and then you fire the event by specifying the event by name as well as any required parameters as defined by the associated delegate.

  1. if (MyEvent != null)  
  2.     MyEvent(message);  
So far so good, in the previous section you saw how to define an event and the delegate associated with it and how to raise this event.

Now you will see how the other parts of the application can respond to the event. To do this you just need to register the event handlers.

when you want to register an event handler with an event you must follow this pattern:
  1. MyClass myClass1 = new MyClass();  
  2. MyClass.MyDelegate del = new MyClass.MyDelegate(myClass1_MyEvent);  
  3. myClass1.MyEvent += del;  
or you can do this in one line of code
  1. myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);  
  2. //this is the event handler  
  3. //this method will be executed when the event raised.  
  4. static void myClass1_MyEvent(string message) {  
  5.     //do something to respond to the event.  
  6. }  
Let's see a full example to demonstrate the concept,
  1. namespace EventsInCSharp {  
  2.     public class MyClass {  
  3.         public delegate void MyDelegate(string message);  
  4.         public event MyDelegate MyEvent;  
  5.         //this method will be used to raise the event.  
  6.         public void RaiseEvent(string message) {  
  7.             if (MyEvent != null) MyEvent(message);  
  8.         }  
  9.     }  
  10.     class Program {  
  11.         static void Main(string[] args) {  
  12.             MyClass myClass1 = new MyClass();  
  13.             myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);  
  14.             Console.WriteLine("Please enter a message\n");  
  15.             string msg = Console.ReadLine();  
  16.             //here is we raise the event.  
  17.             myClass1.RaiseEvent(msg);  
  18.             Console.Read();  
  19.         }  
  20.         //this method will be executed when the event raised.  
  21.         static void myClass1_MyEvent(string message) {  
  22.             Console.WriteLine("Your Message is: {0}", message);  
  23.         }  
  24.     }  
  25. }  
we are doing great, but what if you want to define your event and it's associated delegate to mirrors Microsoft's recommended event pattern. To do so you must follow this patten,
  1. public delegate void MyDelegate(object sender, MyEventArgs e);  
  2. public event MyDelegate MyEvent;  
As you can see the first parameter of the delegate is a System.Object, while the second parameter is a type deriving from System.EventArgs.

The System.Object parameter represents a reference to the object that sent the event(such as MyClass), while the second parameter represents information regarding the event.

If you define a simple event that is not sending any custom information, you can pass an instance of EventArgs directly.

let's see an example,
  1. namespace MicrosoftEventPattern {  
  2.     public class MyClass {  
  3.         public delegate void MyDelegate(object sender, MyEventArgs e);  
  4.         public event MyDelegate MyEvent;  
  5.         public class MyEventArgs: EventArgs {  
  6.             public readonly string message;  
  7.             public MyEventArgs(string message) {  
  8.                 this.message = message;  
  9.             }  
  10.         }  
  11.         //this method will be used to raise the event.  
  12.         public void RaiseEvent(string msg) {  
  13.             if (MyEvent != null) MyEvent(thisnew MyClass.MyEventArgs(msg));  
  14.         }  
  15.     }  
  16.     class Program {  
  17.         static void Main(string[] args) {  
  18.             MyClass myClass1 = new MyClass();  
  19.             myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);  
  20.             Console.WriteLine("Please enter a message\n");  
  21.             string msg = Console.ReadLine();  
  22.             //here is we raise the event.  
  23.             myClass1.RaiseEvent(msg);  
  24.             Console.Read();  
  25.         }  
  26.         static void myClass1_MyEvent(object sender, MyClass.MyEventArgs e) {  
  27.             if (sender is MyClass) {  
  28.                 MyClass myClass = (MyClass) sender;  
  29.                 Console.WriteLine("Your Message is: {0}", e.message);  
  30.             }  
  31.         }  
  32.     }  
  33. }  
we are done now, in my next article i'll show you how to define your custom event to use it in a custom control in a windows application.