Module 4 - Chapter 1: Delegates and Events in C#

In C#, delegates and events are foundational concepts that enable a flexible and extensible way to handle method callbacks and notifications. They play a crucial role in designing and implementing event-driven programming patterns, which are central to developing interactive applications such as graphical user interfaces, game development, and service-oriented applications. This chapter introduces delegates and events, explaining their uses, syntax, and how they enable managed event handling in C#.

Hamdam Muqimov

Mar 29, 2024

Delegates and Events in C#

Delegates

A delegate is a type that represents references to methods with a particular parameter list and return type. When you instantiate a delegate, you can associate its instance with any method with a compatible signature and return type. You can invoke (or call) the method through the delegate instance.

Defining and Using Delegates

To define a delegate, you use the delegate keyword followed by a method signature:


public delegate void MyDelegate(string message);

This delegate can encapsulate a method that takes a single string parameter and returns void.

Example of Using a Delegate


public class DelegateExample
{
    public static void ShowMessage(string message)
    {
        Console.WriteLine(message);
    }

    public static void ExecuteDelegate()
    {
        MyDelegate del = new MyDelegate(ShowMessage);
        del("Hello, World!"); // Invokes ShowMessage through the delegate
    }
}

Events

An event is a way for a class to provide notifications to its clients when something of interest happens to an object. The class that sends (or raises) the event is called the publisher, and the classes that receive (or handle) the event are called subscribers. In C#, events are based on the delegate model.

Defining and Raising Events

You define an event in a class using the event keyword, followed by the delegate type that represents the method signature for the event handlers.


public class EventExample
{
    public delegate void MyEventHandler(string message);

    // Define an event
    public event MyEventHandler MyEvent;

    protected virtual void OnMyEvent(string message)
    {
        MyEvent?.Invoke(message);
    }

    public void RaiseEvent()
    {
        OnMyEvent("Event triggered!");
    }
}

Subscribing to Events

To respond to an event, you define a method in a subscriber class that matches the delegate signature, and then you subscribe to the event using the += operator.


public class Subscriber
{
    public void Subscribe(EventExample publisher)
    {
        publisher.MyEvent += HandleEvent;
    }

    void HandleEvent(string message)
    {
        Console.WriteLine($"Event received: {message}");
    }
}

Key Points

Delegates are used to encapsulate methods as objects, enabling the dynamic invocation of methods.

Events use delegates behind the scenes to manage subscriptions and notifications in a decoupled way.

Events follow a publisher/subscriber model, allowing publishers to notify subscribers about occurrences.

Summary

Delegates and events in C# are powerful constructs that allow for dynamic method invocation and a decoupled way to handle notifications and callbacks. Understanding and effectively using delegates and events are crucial for developing responsive, event-driven applications in C#. They enable your applications to be more modular, extensible, and maintainable by separating event handling and event notification logic.

Module 4 - Chapter 2: Generics in C# Module 5 - Chapter 2: Entity Framework Basics

Hamdam Muqimov

Software Engineer and Researcher at Digitrack Inc. Building Mobile, Desktop, Web and server-side softwares.