CSharp Guide : What is Delegate in C# with Example

What is Delegate in C# with Example : Delegates are a fundamental and powerful feature in C#, often considered as pointers to functions. C# Delegate provide a way to encapsulate a method call and are pivotal in implementing event handling and callback methods. In this blog post, we’ll dive deep into what delegates are, how they work, and how you can use them with real-time examples.

Understanding Delegate in C#

What is a Delegate in C#?

In C#, a delegate is a type that specifies a method signature. It can reference a method with a matching signature, meaning the method must have the same return type and parameter list. This makes delegates similar to function pointers in C and C++ but safer and more secure.

Learn about Design Patterns in c# with Examples.

Key Points about Delegates:

  • Delegates are type-safe.
  • They can reference both static and instance methods.
  • Delegates can be chained together, allowing multiple methods to be invoked from a single event.
  • Delegates are often used in designing extensible and flexible applications (e.g., in event handling in Windows Forms).

Syntax of Delegates

To declare a delegate, you use the delegate keyword, followed by a return type and a parameter list. Here’s a simple example:

What is Delegate in C# with Example
Delegate in C# with Example

This declaration defines a delegate named MyDelegate that can reference any method that takes a single string parameter and returns void.

Basic Delegate in C# Example

Let’s look at a basic example to understand how delegates work. Consider the following program:


  1. Step 1: We declare a delegate named DisplayMessage.
  2. Step 2: We create an instance of the delegate and assign it to the ShowMessage method.
  3. Step 3: We call the delegate, which in turn calls the ShowMessage method.
  4. Step 4: We add another method to the delegate invocation list using the += operator, demonstrating multicast delegates.

Real-Time Example: Using Delegates for Callbacks

In real-world applications, delegates are extensively used for implementing callbacks. For instance, you might have a method that performs a long-running task and need to notify the calling code when the task is complete.

Here you can learn about Dependency Injection in .NET Core with Example.

Here’s a practical example:


  1. Delegate Definition: NotifyCallback is a delegate type for the callback.
  2. LongRunningTask Method: This method simulates a long task using Thread.Sleep.
  3. Callback Invocation: Once the task is complete, the delegate callback is invoked.
  4. Main Method: The LongRunningTask is called with TaskCompleted as the callback method.

Advanced Use Case: Event Handling with Delegates

Delegates serve as the cornerstone of event handling in C#. Events are special multicast delegates that are used to broadcast a message to multiple subscribers. Here’s how you can use delegates for event handling:

Step-by-Step Example


  1. Delegate Definition: NotifiesEventHandler is a delegate type for the event.
  2. Publisher Class: This class declares an event named Notify using the delegate.
  3. RaiseEvent Method: This method raises the event, checking if there are any subscribers.
  4. Subscriber Class: This class has a method OnNotify that handles the event.
  5. Main Method: The Publisher raises the event, which is handled by the Subscriber.


Delegates are a powerful feature in C#, enabling flexible and reusable code. They allow methods to be passed as parameters and support asynchronous programming patterns like callbacks and events. By understanding and utilizing delegates, you can write more robust and maintainable C# applications.

In this post, we covered:

  • The basic concept and syntax of delegates.
  • A simple delegate example.
  • A real-time example using delegates for callbacks.
  • How to use delegates for event handling.

By applying these concepts, you can leverage the full potential of delegates in your C# programming. Whether you are implementing simple callbacks or complex event-driven architectures, delegates provide a robust mechanism for method abstraction and execution.

Leave a Reply

Your email address will not be published. Required fields are marked *