Event Handling in C# using Delegates: An Example-Driven Guide

Event handling in C# can be implemented using `delegates`. A delegate is a type-safe, object-oriented function pointer that can be used to refer to a method in C# and pass it as a parameter to another method. This allows methods to be passed around and executed dynamically at runtime, making them a perfect fit for event handling in C#.
Here is an example of event handling in C# using delegates:

using System;
delegate void ButtonClickHandler(object sender, EventArgs e);
class Button 
{ 
    public event ButtonClickHandler Click; 
    public void OnClick() 
    { 
        if (Click != null) 
        { 
            Click(this, EventArgs.Empty); 
        } 
    } 
} 
class Program 
{ 
    static void Main(string[] args) 
    { 
        Button button = new Button(); 
        button.Click += Button_Click; 
        button.OnClick(); 
    } 
    static void Button_Click(object sender, EventArgs e) 
    { 
        Console.WriteLine("Button was clicked"); 
    } 
}

In this example, we have defined a delegate `ButtonClickHandler` that refers to methods that take two parameters, an `object` and an `EventArgs`, and return no value. The Button class then declares a public event of type `ButtonClickHandler` called `Click`.
The Program class subscribes to the `Click` event by using the `+=` operator. This means that the `Button_Click` method will be executed whenever the `Click` event is raised. When the `OnClick` method is called, the `Click` event is raised, and the `Button_Click` method is executed.
This demonstrates how delegates can be used to handle events in C#. By using delegates, you can create type-safe event handlers that are strongly typed and easy to use. This makes event handling in C# more robust, flexible, and scalable, allowing you to respond to events and take appropriate action in your application.

Related Topics:
Delegates in C#: An Overview
Understanding Generic and Non-Generic Delegates in C#

Multicast Delegate in C#: An Overview