How to Implement Events In C#

Introduction

Events are members of the class that raises them. When something happens, a class can raise an event, which has a message that contains information 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 executing methods called event handlers.

An 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 is raised, and then you define the event based on that delegate.

Example

public class MyClass
{
public delegate void MyDelegate(string message);
public event MyDelegate MyEvent;
}

Raising an event is a simple step. First, you check the event against a null value to ensure that the caller has registered with the event. Then you fire the event by specifying the event by name and any required parameters defined by the associated delegate.

Example

if (MyEvent != null)
MyEvent(message);

So far, so good. In the previous section, you saw how to define an event, the delegate associated with it, and how to raise it.

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

When you want to register an event handler with an event, you must follow this pattern:

MyClass myClass1 = new MyClass();
MyClass.MyDelegate del = new MyClass.MyDelegate(myClass1_MyEvent);
myClass1.MyEvent += del;

or you can do this in one line of code

myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);
//this is the event handler
//this method will be executed when the event is raised.
static void myClass1_MyEvent(string message) {
//do something to respond to the event.
}

Let's see a full example to demonstrate the concept,

namespace EventsInCSharp {
public class MyClass {
public delegate void MyDelegate(string message);
public event MyDelegate MyEvent;
//this method will be used to raise the event.
public void RaiseEvent(string message) {
if (MyEvent != null) MyEvent(message);
}
}
class Program {
static void Main(string[] args) {
MyClass myClass1 = new MyClass();
myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);
Console.WriteLine("Please enter a message\n");
string msg = Console.ReadLine();
//here is we raise the event.
myClass1.RaiseEvent(msg);
Console.Read();
}
//this method will be executed when the event is raised.
static void myClass1_MyEvent(string message) {
Console.WriteLine("Your Message is: {0}", message);
}
}
}

We are doing great, but what if you want to define your event and its associated delegate to mirror Microsoft's recommended event pattern? To do so, you must follow this pattern,

public delegate void MyDelegate(object sender, MyEventArgs e);
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,

namespace MicrosoftEventPattern {
public class MyClass {
public delegate void MyDelegate(object sender, MyEventArgs e);
public event MyDelegate MyEvent;
public class MyEventArgs: EventArgs {
public readonly string message;
public MyEventArgs(string message) {
this.message = message;
}
}
//this method will be used to raise the event.
public void RaiseEvent(string msg) {
if (MyEvent != null) MyEvent(this, new MyClass.MyEventArgs(msg));
}
}
class Program {
static void Main(string[] args) {
MyClass myClass1 = new MyClass();
myClass1.MyEvent += new MyClass.MyDelegate(myClass1_MyEvent);
Console.WriteLine("Please enter a message\n");
string msg = Console.ReadLine();
//here is we raise the event.
myClass1.RaiseEvent(msg);
Console.Read();
}
static void myClass1_MyEvent(object sender, MyClass.MyEventArgs e) {
if (sender is MyClass) {
MyClass myClass = (MyClass) sender;
Console.WriteLine("Your Message is: {0}", e.message);
}
}
}
}

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.

14 Comments

Join the conversation! Your thoughts help the community grow.

prideaux905y ago
"Events use Delegates internally. Events are encapsulation over Delegates" Ok, can you please point to an MSDN reference that mentions this ?
Subin Thomas7y ago
Easy and nice article
Subash10y ago
Nice
Lalit Raghav11y ago
Nice
Raja T11y ago
Nice,Thanks for sharing
Former member11y ago
Thanks
Santhakumar Munuswamy11y ago
Good one
Former member11y ago
Thanks
Humayun Kabir Mamun11y ago
Nice...
Harshad Pansuriya11y ago
Nice one
Former member11y ago
Thanks
Mukesh Kumar11y ago
Good Job
Rajeesh Menoth11y ago
Nice Share!
Former member11y ago
Thanks for publishing