Creating and Invoking Delegates in C#

Delegates are a powerful feature in the C# programming language that allow for encapsulating and passing methods as objects. They enable the creation of callback functions and event handlers, making it easier to write reusable and extensible code. In this article, we will explore the process of creating and invoking delegates in C#.

Understanding Delegates

A delegate in C# is a type that defines a method signature, encapsulating a reference to a method. It is similar to a function pointer in C/C++ but is type-safe and object-oriented. Delegates are declared using the delegate keyword, followed by the return type and parameter types of the method it will encapsulate.

delegate void MyDelegate(string message);

In the above example, we have declared a delegate named MyDelegate that encapsulates methods with a void return type and a single string parameter.

Creating Delegates

Delegates can be instantiated by providing the name of the method or lambda expression that they will point to. The method signature of the delegate and the method being assigned to it should match. Let's consider the following example:

public static void DisplayMessage(string message)
{
    Console.WriteLine($"Message: {message}");
}

public static void Main()
{
    MyDelegate myDelegate = new MyDelegate(DisplayMessage);
    myDelegate("Hello, world!");
}

In the above code, we define a method named DisplayMessage that takes a string parameter and displays it on the console. Then, we create an instance of the MyDelegate delegate by passing the DisplayMessage method as an argument.

Invoking Delegates

Once a delegate is created, it can be invoked as if it were the method it encapsulates. This is done by using the delegate instance followed by parentheses and passing the arguments. In our previous example, we invoked the delegate using myDelegate("Hello, world!");.

Multicast Delegates

C# also supports multicast delegates, which are delegates that can reference multiple methods. To combine multiple methods into a multicast delegate, we use the += operator. Let's see an example:

public static void MethodA(string message)
{
    Console.WriteLine($"Method A: {message}");
}

public static void MethodB(string message)
{
    Console.WriteLine($"Method B: {message}");
}

public static void Main()
{
    MyDelegate myDelegate = MethodA;
    myDelegate += MethodB;
    myDelegate("Hello, world!");
}

In the above code, we have two methods, MethodA and MethodB, with the same signature as our delegate. We create a delegate instance myDelegate and then use the += operator to combine both methods. When we invoke myDelegate, both MethodA and MethodB will be called in the order they were added.

Conclusion

Delegates are a powerful feature in C# that allow for encapsulating and passing methods as objects. They provide a convenient way to create callback functions and event handlers. In this article, we learned how to create and invoke delegates, as well as how to use multicast delegates. Understanding delegates enables us to write more reusable and extensible code in C#.