Effective Use of Delegates for Implementing Callbacks in C#

Introduction to Delegates in C#

Delegates in C# are types that represent references to methods with a specific signature type. They allow you to encapsulate a method in an object, which is particularly useful for implementing callbacks and events. A delegate can be considered as a function pointer, allowing you to pass methods as parameters to other methods (TUTORIALSPOINT, 2025).

The definition of a delegate is made using the delegate keyword, followed by the signature of the method that it will reference. Let's consider a simple example of a delegate that represents a method that takes two integers and returns an integer.

public delegate int Operation(int x, int y);

public class Calculator
{
    public int Add(int x, int y) => x + y;
    public int Subtract(int x, int y) => x - y;
}
    

Implementing Callbacks with Delegates

Callbacks are a technique where a method is passed as an argument to another method. This is useful in situations where you want a method to perform a specific operation after completing a task. With delegates, the implementation of callbacks becomes more straightforward and organized (IDC ONLINE, 2025).

In the example below, we will create a method that accepts a delegate as an argument, allowing the user to choose the operation to be performed after executing a task.

public void ExecuteOperation(Operation operation, int a, int b)
{
    int result = operation(a, b);
    Console.WriteLine($"Result: {result}");
}

// Usage
var calculator = new Calculator();
ExecuteOperation(calculator.Add, 5, 3); // Result: 8
ExecuteOperation(calculator.Subtract, 5, 3); // Result: 2
    

Multicast Delegates

Multicast delegates allow you to associate multiple methods with a single delegate. When the delegate is invoked, all associated methods are executed in sequence. This is especially useful in events, where you may have multiple event handlers (IDC ONLINE, 2025).

public delegate void Notification(string message);

public class Notifier
{
    public Notification OnNotification;

    public void SendNotification(string message)
    {
        OnNotification?.Invoke(message);
    }
}

// Usage
var notifier = new Notifier();
notifier.OnNotification += msg => Console.WriteLine($"Received: {msg}");
notifier.OnNotification += msg => Console.WriteLine($"Log: {msg}");
notifier.SendNotification("New message!"); // Received: New message! Log: New message!
    

Delegates and LINQ

The use of delegates extends to LINQ (Language Integrated Query), where you can pass lambda expressions as delegates. This allows you to write queries in a concise and expressive way.

using System;
using System.Collections.Generic;
using System.Linq;

var numbers = new List { 1, 2, 3, 4, 5 };
var squares = numbers.Select(n => n * n).ToList();

Console.WriteLine(string.Join(", ", squares)); // Output: 1, 4, 9, 16, 25
    

Generic Delegates

In C#, it is also possible to create generic delegates, which allow the definition of a delegate that can operate on different types of data. This increases flexibility and code reuse.

public delegate T GenericResult(T x, T y);

public class Example
{
    public T Calculate(GenericResult operation, T a, T b)
    {
        return operation(a, b);
    }
}

// Usage
var example = new Example();
var sum = example.Calculate((x, y) => x + y, 3, 4); // 7
var concat = example.Calculate((x, y) => x + y, "Hello, ", "world!"); // Hello, world!
    

Events and Delegates

Events in C# are a way to encapsulate delegation logic, allowing classes to publish notifications about state changes. Events are based on delegates and are typically declared as public delegates.

public class Counter
{
    private int _count;
    public event Notification CountChanged;

    public void Increment()
    {
        _count++;
        CountChanged?.Invoke($"Current count: {_count}");
    }
}

// Usage
var counter = new Counter();
counter.CountChanged += msg => Console.WriteLine(msg);
counter.Increment(); // Current count: 1
counter.Increment(); // Current count: 2
    

Performance Considerations

Although the use of delegates and callbacks in C# is extremely useful, it is important to consider the performance impact, especially in critical applications. Delegates can introduce overhead due to object creation and method invocation. Therefore, it is advisable to use delegates wisely and consider alternatives when necessary.

Practical Example: Event Notification System

Let's explore a practical example of an event notification system using delegates. In this system, a class Event will trigger notifications when a specific event occurs, such as the completion of a task.

public class Event
{
    public event Notification EventNotification;

    public void TaskCompleted()
    {
        EventNotification?.Invoke("The task has been successfully completed!");
    }
}

// Usage
var eventExample = new Event();
eventExample.EventNotification += msg => Console.WriteLine($"Notification: {msg}");
eventExample.TaskCompleted(); // Notification: The task has been successfully completed!
    

Delegates and Asynchronous Programming

Delegates also prove extremely useful in asynchronous programming contexts, where you may want to execute methods after completing a long operation without blocking the user interface. Using delegates with async and await facilitates this implementation.

public async Task ProcessDataAsync()
{
    await Task.Run(() =>
    {
        // Simulate a long-running process
        Thread.Sleep(2000);
    });

    EventNotification?.Invoke("Processing completed.");
}

// Usage
public async Task Execute()
{
    Event eventExample = new Event();
    eventExample.EventNotification += msg => Console.WriteLine(msg);
    await eventExample.ProcessDataAsync(); // Processing completed.
}
    

Delegates as Method Parameters

Another important application of delegates is passing them as parameters to methods. This increases the flexibility of methods, as you can change their behavior without modifying their internal code (WAGNER, 2011).

public void ExecuteWithCallback(Action callback)
{
    // Main method logic
    Console.WriteLine("Executing main logic...");
    
    // Calls the callback after execution
    callback();
}

// Usage
ExecuteWithCallback(() => Console.WriteLine("Callback executed!"));
    

Comparison between Delegates and Interfaces

Often, there can be confusion between the use of delegates and interfaces to implement callbacks. While delegates are simpler and more straightforward, interfaces provide a more robust structure and can be used to implement multiple inheritance. The choice between one and the other depends on the context of the application.

Conclusion

Delegates are a powerful tool in C# that allows for the efficient implementation of callbacks and events. With the examples presented, you should have a better understanding of how to use delegates in your applications. From basic implementation to usage in LINQ and events, delegates offer flexibility and expressiveness to your code. When utilizing this functionality, always remember to consider the performance and clarity of your code.