A Beginner's Guide to C# Delegates and Events

What are Delegates?

Delegates are like function pointers in C#. They are used to define method signatures and can point to any method that matches that signature. This allows for flexibility in executing methods.

Example of a Delegate

Here’s a simple example:

// Step 1: Declare a delegate
public delegate void Notify();

// Step 2: Create a class that uses the delegate
public class ProcessBusinessLogic
{
    public Notify OnProcessCompleted;

    public void StartProcess()
    {
        Console.WriteLine("Process Started!");
        // Simulating some process work
        Thread.Sleep(2000);
        // Notify that the process is completed
        OnProcessCompleted?.Invoke();
    }
}

// Step 3: Subscribe to the delegate and use it
public class Program
{
    public static void Main(string[] args)
    {
        ProcessBusinessLogic bl = new ProcessBusinessLogic();
        bl.OnProcessCompleted += Bl_OnProcessCompleted;
        bl.StartProcess();
    }

    private static void Bl_OnProcessCompleted()
    {
        Console.WriteLine("Process Completed!");
    }
}

Explanation:

1. Declare a Delegate: We define a delegate named Notify that does not take any parameters and does not return a value.
2. Create a Class: The class ProcessBusinessLogic contains a delegate instance OnProcessCompleted and a method StartProcess that simulates a process.
3. Invoke the Delegate: After the work is done, we invoke OnProcessCompleted to notify subscribers that the process is complete.
4. Subscribe to the Delegate: In the Main method, we create an instance of ProcessBusinessLogic, subscribe to the OnProcessCompleted event, and start the process.

What are Events?

Events are built on top of delegates and provide a way for a class to notify other classes or objects when something of interest occurs. Events follow the publisher-subscriber model.

Example of an Event

Here’s how you can use events in C#:

// Step 1: Define a delegate
public delegate void ProcessCompletedEventHandler(object sender, EventArgs e);

// Step 2: Create a class that uses the event
public class BusinessLogic
{
    public event ProcessCompletedEventHandler ProcessCompleted;

    public void StartProcess()
    {
        Console.WriteLine("Process Started!");
        Thread.Sleep(2000);
        // Raise the event
        OnProcessCompleted();
    }

    protected virtual void OnProcessCompleted()
    {
        ProcessCompleted?.Invoke(this, EventArgs.Empty);
    }
}

// Step 3: Subscribe to the event
public class Program
{
    public static void Main(string[] args)
    {
        BusinessLogic bl = new BusinessLogic();
        bl.ProcessCompleted += Bl_ProcessCompleted;
        bl.StartProcess();
    }

    private static void Bl_ProcessCompleted(object sender, EventArgs e)
    {
        Console.WriteLine("Process Completed Event Triggered!");
    }
}

Explanation:

1. Define a Delegate: We define a delegate ProcessCompletedEventHandler that takes two parameters: sender and EventArgs.
2. Create a Class: The class BusinessLogic contains an event ProcessCompleted that uses our delegate.
3. Raise the Event: The method OnProcessCompleted raises the event and notifies all subscribers.
4. Subscribe to the Event: In the Main method, we subscribe to the ProcessCompleted event and define what happens when the event is triggered.

Conclusion

Delegates and events are powerful features in C# that help you create flexible and maintainable code. By understanding how to use them effectively, you can build applications that respond to various actions and changes in state. Try implementing these examples in your own projects to see how they can enhance your coding experience!