Delegates in C# with Real-Time Example

Delegates in C# are a type-safe way of representing references to methods with a particular parameter list and return type. This feature enables developers to assign methods to variables, pass methods as arguments, and return methods from other methods. Delegates provide a level of abstraction and can be seen as function pointers, but unlike function pointers in C or C++, they are object-oriented, type-safe, and secure.

A common real-time example of using delegates is event handling within the .NET framework. Delegates serve as the backbone for events, allowing event listeners to subscribe to, or be notified of, occurrences within a program. They encapsulate a method that is called in response to an event, decoupling the event sender from the receiver.

For instance, consider a user interface application with buttons where actions are triggered when a button is clicked. Delegates are essential in providing the mechanism to define what should happen on a button click without the button needing to know the specifics of the functionality it invokes. This promotes a modular and maintainable approach where the button’s click event is associated with a delegate that points to a method encapsulating the desired action.

Understanding Delegates in C#

Delegates in C# are a type of object that points to a method. They allow methods to be passed as parameters, used as callback functions, or assigned to events, giving C# programmers a flexible way to handle method invocation. Delegates are type-safe, meaning that they enforce the signature of the method they reference, preventing runtime errors related to method signatures.

C# provides three types of delegates:

  • Single-cast delegates: Hold a reference to a single method.
  • Multicast delegates: Can hold references to multiple methods.
  • Predfined delegates: Func<>, Action<>, and Predicate<> are common predefined delegates in the .NET Framework.

A real-time example of using a delegate is an event handling system within a user interface (UI) framework. When a button is clicked, its associated delegate will be called to execute the button’s click event handler.

Here is a simple example of a single-cast delegate usage:

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

public class Calculator
    public int Add(int a, int b)
        return a + b;

class Program
    static void Main(string[] args)
        var calc = new Calculator();
        PerformCalculation calcDelegate = calc.Add;
        int result = calcDelegate(5, 10);

In this code, PerformCalculation is a delegate which points to the Add method of the Calculator class. When calcDelegate is invoked, it executes the Add method and outputs the result to the console.

You can see the output in the screenshot below after I executed the script using Visual Studio.

Delegates in C#

Using C# Delegates in Real-Time Scenarios

In C#, delegates are a fundamental concept used to encapsulate method references within a variable, which can then be passed around like any other variable. They are particularly useful in real-time scenarios where an application requires callback methods.

Consider a simple real-time chat application. Delegates are employed to invoke methods that broadcast messages to all connected clients. Instead of directly calling a method, the server uses a delegate with a signature matching the broadcast method:

public delegate void MessageBroadcast(string message);

When a new message is received, the delegate is called, allowing any method that matches its signature to react accordingly. For example:

Client-Side Subscription:

public void RegisterOnMessageReceived(MessageBroadcast broadcaster)
    broadcaster += DisplayChatMessage;

private void DisplayChatMessage(string message)
    Console.WriteLine("New message: " + message);

Server-Side Invocation:

public void BroadcastMessage(string message, MessageBroadcast broadcaster)

Another scenario involves real-time data processing systems, such as stock price analysis tools. These systems may define a delegate to handle new stock price updates:

Stock Price Update Delegate:

public delegate void PriceUpdatedHandler(Stock stock);

Subscribers can implement specific strategies or logging mechanisms on price updates, without being tightly coupled to the data source. This provides flexibility and the option to easily exchange strategies.

Example Strategy Subscription:

public void SubscribeToPriceUpdate(PriceUpdatedHandler handler)
    handler += AnalyzeStockPrice;

private void AnalyzeStockPrice(Stock stock)
    // Implement analysis logic for stock price update.

By using delegates, C# programmers can write applications that are modular and flexible, with components that are easily interchangeable and adaptable to various real-time interaction patterns.

Creating Custom Delegates in C#

In C#, a delegate is a type that safely encapsulates a method, similar to a function pointer in C and C++. Custom delegates are declared using the delegate keyword.

Defining a Delegate: To define a custom delegate, one specifies the return type and the parameters it must take. For instance:

public delegate int MathOperation(int a, int b);

This declaration defines a delegate named MathOperation that can encapsulate any method that takes two integers as parameters and returns an integer.

Using the Delegate: After defining a delegate, it can be instantiated with a method that has a compatible signature.

static int Add(int a, int b){
    return a + b;

MathOperation addOperation = new MathOperation(Add);

Note: C# 2.0 introduced the concept of anonymous methods and C# 3.0 introduced lambda expressions, which allow for a more concise way to define delegate instances.

Example: Consider an example where a delegate is used to perform a calculation.

  1. Define the delegate: public delegate double CalculateArea(double dimension);
  2. Declare methods to use with the delegate: static double AreaOfSquare(double side){ return side * side; } static double AreaOfCircle(double radius){ return Math.PI * radius * radius; }
  3. Instantiate and use the delegate: CalculateArea squareArea = new CalculateArea(AreaOfSquare); CalculateArea circleArea = new CalculateArea(AreaOfCircle); double square = squareArea(4); double circle = circleArea(5);

In this example, the custom delegates squareArea and circleArea are used to reference methods that calculate the areas of a square and a circle, demonstrating the versatility and reusability of delegates in C#.

Delegates with Built-In Func and Action Types

In C#, delegates serve as type-safe pointers to methods. For common scenarios, the .NET Framework provides two built-in generic delegate types: Func<> and Action<>.

Action<> delegates are used when pointing to a method that does not return a value. They can have zero to 16 parameters of different types. For instance:

Action<string> greet = name => Console.WriteLine($"Hello, {name}!");
greet("Alice"); // Output: Hello, Alice!

On the other hand, Func<> delegates refer to methods that return a value. The last type parameter specifies the return type, with up to 16 input parameters. Consider the following example:

Func<int, int, int> add = (x, y) => x + y;
int result = add(3, 2); // Output: 5

Here’s a quick reference table highlighting their differences:

Delegate TypeReturn TypeExample Use-Cases
ActionvoidLogging, Printing, Actions
FuncSpecified by the last generic type parameterCalculations, Data Retrieval

To sum up, Action<> and Func<> provide convenient ways to declare delegates. They streamline method referencing without needing to define custom delegate types, thereby leading to cleaner and more maintainable code.

Multicast Delegates in C#

In C#, multicast delegates are delegates that hold references to multiple methods. They enable the invocation of several methods with a single delegate. The System.Delegate class forms the basis of multicast delegates, which use the += operator to add multiple methods and the -= operator to remove them.

Key Property:

  • Invocation List: A multicast delegate has an invocation list that contains the pointers to the methods it can call.

Example Usage:

  1. Declaration and Instantiation
public delegate void PrintDelegate(string message);
PrintDelegate printDel = null;
  1. Adding Methods
printDel += PrintToConsole;
printDel += PrintToFile;
  1. Invocation
printDel("Hello World");

The above code will call PrintToConsole and PrintToFile in sequence.

Note: If one method in the invocation list throws an exception, the subsequent methods are not called. Exception handling is critical to ensure all desired methods are executed.

Removing Methods:

printDel -= PrintToFile; // Removes PrintToFile method from the invocation list

Iterating Over the Invocation List:

  • You can iterate through the list of methods assigned to a multicast delegate and invoke each one individually.

Here is a simple example where each method will receive the same argument:

foreach (Delegate method in printDel.GetInvocationList())
    method.DynamicInvoke("Hello Multicast");

Best Practices for Using Delegates in C#

When implementing delegates in C#, developers should adhere to several best practices to ensure efficiency, maintainability, and clarity in their code.

Define Delegates with Clear Intentions: Delegates should be named with meaningful conventions that reflect their usage and the types of methods they are intended to reference. For instance, ActionHandler or DataProcessor.

Keep Delegates Lean: Delegates are best used for specific, well-defined tasks. Overloading a delegate with too many responsibilities can make the code harder to maintain.

Avoid Anonymous Methods for Complex Logic: While anonymous methods can be convenient for inline delegate definitions, they should not contain complex logic. When the logic is more involved, it’s preferable to use named methods, which are easier to debug and test.

Reuse Built-in Delegates: Whenever possible, use the built-in generic delegates Func<> and Action<> provided by the .NET framework. This can reduce the need for custom delegate types and provide more consistency in codebases.

Delegate TypeUse Case
Func<>When a return value is expected.
Action<>When no return value is needed.

Delegate Lifetimes: Developers must be cautious of the lifetimes of delegates, especially in the context of event handlers. Unsubscribing from events is as essential as subscribing to prevent memory leaks.

Immutability Principle: When capturing variables in a delegate, especially in a multithreaded environment, ensure that these variables are immutable to avoid side effects or race conditions.

Error Handling: Delegates should include proper exception handling, as exceptions within delegates can sometimes be harder to trace.

By observing these practices, developers can effectively leverage the power of delegates in their C# applications, leading to robust and clean code.


Delegates in C# are a robust mechanism for encapsulating methods with a specific signature. They enable developers to design flexible and reusable applications. Through the use of delegates, event-driven programming becomes streamlined, enhancing the robustness of applications.

  • Functionality: Delegates offer a way to pass methods as arguments, making code more modular.
  • Flexibility: They enable event-driven programming, a cornerstone of modern software development.
  • Performance: While delegates provide substantial functionality, they must be used judiciously to maintain performance.

Developers often employ delegates to define callback methods and implement observer patterns. Delegates are crucial in constructing events and anonymous methods with lambda expressions. In essence, they serve as bridges between event sources and event handlers.

Common scenarios for delegate usage include:

  • UI Interaction: Responding to user actions in graphical user interfaces.
  • Asynchronous Programming: Facilitating callbacks for asynchronous operations.

In practice, understanding and implementing delegates can considerably improve the design patterns utilized in an application, leading to clean, maintainable, and scalable code. They are fundamental components that all proficient C# programmers should master.

You may also like: