What are and how to use Events in C#

An event in C# is a mechanism that allows a class or an object to notify other classes or objects that something has occurred.

When an event occurs, the associated methods are called, allowing classes to react to the triggered actions.

Event Syntax

To define an event, we first have to define a delegate type that specifies the signature of the method that we want to respond to the event. We call this function handler.

On the other hand, we need to declare the event itself. This uses the delegate type we defined earlier, preceding the reserved word event.

Let’s see it with an example,

// definition of the function that will handle the event
public delegate void MyEventHandler(string message);

public class Publisher
{
    // definition of the event
    public event MyEventHandler MyEvent;

    public void Notify(string message)
    {
        MyEvent?.Invoke(message);
    }
}

In this example,

Finally, when “whatever generates the event” has occurred, and we want to trigger it, we do

MyEvent?.Invoke(message)

How to Consume Events

We already know how to define and trigger Events. Now let’s see how other parts of the program can subscribe to these events to be informed that something has happened.

Subscribing to Events

To subscribe to an event, the += operator is used, adding an event handler method that matches the event delegate’s signature.

public static void PrintMessage(string message)
{
    Console.WriteLine("Event received: " + message);
}

// create a publisher object
var publisher = new Publisher();

// subscribe PrintMessage to the event
publisher.MyEvent += PrintMessage;

// force trigger the event
publisher.Notify("Hello, event!");

// Output:
// Event received: Hello, event!

In a real project, the Publisher object would be doing its tasks. When it wants to inform that it is launching…

Unsubscribing from Events

To unsubscribe from an event, the -= operator is used, removing the event handler method from the event.

publisher.MyEvent -= subscriber.HandleEvent;

Unsubscribing from events is important to avoid memory issues and dangling references, especially in long-running applications.

Using Generic Events

The normal syntax for creating Events in C# is a bit “verbose” because we have to define a delegate with the signature of the method that will handle the event.

To simplify the syntax, the generic delegate EventHandler<TEventArgs> was introduced in version 2.0 of the .NET Framework.

This delegate provides a generic way to handle events, meaning it can handle any type of event arguments without having to define a custom delegate for each type of event.

public class Publisher
{
    // definition of the event
    public event EventHandler<string> MyEvent;

    public void Notify(string message)
    {
        MyEvent?.Invoke(message);
    }
}

Therefore, the functions that subscribe to the Event would have the following form,

publisher.MyEvent += (s, e) => PrintMessage;

Practical Examples

Button button = new Button();
button.Click += (sender, args) => Console.WriteLine("Click event has occurred.");

public class Alarm
{
    public event EventHandler AlarmActivated; // Define an AlarmActivated event

    public void Activate()
    {
        AlarmActivated?.Invoke(this, EventArgs.Empty); // Trigger the AlarmActivated event
    }
}

Alarm alarm = new Alarm();

// Subscribe to the AlarmActivated event
alarm.AlarmActivated += (sender, args) => Console.WriteLine("Alarm activated!");

// Activate the alarm
alarm.Activate();

public class Sender
{
    public event EventHandler<string> MessageSent; // Define a MessageSent event

    public void SendMessage(string message)
    {
        Console.WriteLine($"Message sent: {message}");
        MessageSent?.Invoke(this, message); // Trigger the MessageSent event
    }
}

public class Receiver
{
    public Receiver(Sender sender)
    {
        // Subscribe to the sender's MessageSent event
        sender.MessageSent += (sender, message) => Console.WriteLine($"Message received: {message}");
    }
}

Sender sender = new Sender();
Receiver receiver = new Receiver(sender);

sender.SendMessage("Hello, receiver!");

:::::::