Topic 11218 min readStructured Tutorial

Delegates and Events in C# - Practical Examples

Quick Answer

Delegates in C# are type-safe function pointers that allow methods to be passed as parameters. Events use delegates to enable a publisher-subscriber model, facilitating communication between objects. Practical examples include button click handlers and custom event notifications, essential for responsive and modular applications.

Learning Objectives

Explain the purpose of Practical Examples in a practical learning context.
Identify the main ideas, terms, and decisions involved in Practical Examples.
Apply Practical Examples in a simple real-world scenario or practice task.

Introduction to Delegates and Events

Delegates and events are fundamental concepts in C# that enable event-driven programming.

Delegates act as type-safe pointers to methods, while events provide a way for objects to notify other objects when something happens.

Events and delegates enable loose coupling and flexible communication between components.

Understanding Delegates

A delegate is a type that represents references to methods with a specific parameter list and return type.

Delegates allow methods to be passed as parameters, stored, and invoked dynamically.

Type-safe method references
Can reference static or instance methods
Support multicast invocation

Simple Delegate Example

Here is a simple example demonstrating how to declare and use a delegate.

Working with Events

Events are built on top of delegates and provide a way to subscribe and respond to notifications.

They follow the publisher-subscriber pattern, where the publisher raises events and subscribers handle them.

Events restrict delegate invocation to the declaring class
Subscribers add or remove event handlers
Commonly used in UI programming and asynchronous operations

Basic Event Example

This example shows how to declare an event and subscribe to it.

Practical Examples of Delegates and Events

Let's explore practical scenarios where delegates and events are used effectively.

Button click event handling in GUI applications
Custom event notifications in business logic
Logging and callback mechanisms

Example: Button Click Event Handler

In this example, a button click event is handled using delegates and events.

Example: Custom Event for Data Processing

This example demonstrates raising a custom event when data processing completes.

Practical Example

This example declares a delegate named Notify that points to the ShowMessage method. The delegate is invoked to print a message.

This example shows a Publisher class raising an event and a Subscriber class handling it by subscribing to the event.

This example simulates a button click event where the Click event is raised and handled by a subscribed method.

This example defines a custom event with event data. The DataProcessor raises the event after processing, and the subscriber handles it.

Examples

Simple Delegate Example

public delegate void Notify(string message);

class Program
{
    static void Main()
    {
        Notify notifyDelegate = ShowMessage;
        notifyDelegate("Hello from delegate!");
    }

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

This example declares a delegate named Notify that points to the ShowMessage method. The delegate is invoked to print a message.

Basic Event Example

using System;

class Publisher
{
    public event EventHandler OnChange;

    public void RaiseEvent()
    {
        OnChange?.Invoke(this, EventArgs.Empty);
    }
}

class Subscriber
{
    public void Subscribe(Publisher pub)
    {
        pub.OnChange += HandleEvent;
    }

    private void HandleEvent(object sender, EventArgs e)
    {
        Console.WriteLine("Event received.");
    }
}

class Program
{
    static void Main()
    {
        Publisher pub = new Publisher();
        Subscriber sub = new Subscriber();
        sub.Subscribe(pub);
        pub.RaiseEvent();
    }
}

This example shows a Publisher class raising an event and a Subscriber class handling it by subscribing to the event.

Button Click Event Handler Example

using System;

class Button
{
    public event EventHandler Click;

    public void OnClick()
    {
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        Button button = new Button();
        button.Click += Button_Click;
        button.OnClick();
    }

    private static void Button_Click(object sender, EventArgs e)
    {
        Console.WriteLine("Button was clicked!");
    }
}

This example simulates a button click event where the Click event is raised and handled by a subscribed method.

Custom Event for Data Processing

using System;

class DataProcessor
{
    public event EventHandler<DataEventArgs> DataProcessed;

    public void ProcessData()
    {
        // Simulate data processing
        System.Threading.Thread.Sleep(1000);
        OnDataProcessed(new DataEventArgs("Data processed successfully."));
    }

    protected virtual void OnDataProcessed(DataEventArgs e)
    {
        DataProcessed?.Invoke(this, e);
    }
}

class DataEventArgs : EventArgs
{
    public string Message { get; }
    public DataEventArgs(string message) { Message = message; }
}

class Program
{
    static void Main()
    {
        DataProcessor processor = new DataProcessor();
        processor.DataProcessed += Processor_DataProcessed;
        processor.ProcessData();
    }

    private static void Processor_DataProcessed(object sender, DataEventArgs e)
    {
        Console.WriteLine(e.Message);
    }
}

Best Practices

Use delegates and events to decouple components and promote modular design.
Always check for null before invoking events to avoid exceptions.
Use EventHandler<T> for events with custom data to follow .NET conventions.
Unsubscribe from events when no longer needed to prevent memory leaks.
Keep event handlers short and efficient to maintain responsiveness.

Common Mistakes

Invoking events without null checks causing NullReferenceException.
Not unsubscribing event handlers leading to memory leaks.
Using delegates directly instead of events for public notifications.
Modifying event invocation list from outside the declaring class.
Blocking the main thread with long-running event handlers.

Hands-on Exercise

Create a Custom Event

Implement a class that raises a custom event when a threshold is reached. Write a subscriber that handles this event and prints a message.

Expected output: A message printed when the threshold event is raised.

Hint: Define a delegate or use EventHandler<T>, raise the event when the condition is met, and subscribe to it in another class.

Implement Multicast Delegate

Create a delegate that points to multiple methods and invoke it to see all methods executed.

Expected output: All methods assigned to the delegate are called in order.

Hint: Use the += operator to add methods to the delegate invocation list.

Interview Questions

What is a delegate in C#?

Interview

A delegate is a type-safe object that points to a method or methods with a specific signature, allowing methods to be passed as parameters or assigned to variables.

How do events differ from delegates?

Interview

Events are built on delegates but restrict the invocation of the delegate to the declaring class, providing a controlled way for subscribers to register handlers without invoking the event themselves.

Why should you unsubscribe from events?

Interview

Unsubscribing prevents memory leaks by allowing the garbage collector to reclaim objects that are no longer needed but still referenced by event handlers.