How to work with delegates in C#

Take advantage of delegates to promote flexibility in your designs and implement event-driven programming with ease

Delegates

Delegates

A delegate is a type safe a function pointer that can reference a method that has the same signature as that of the delegate. You can take advantage of delegatese in C# to implement events and call back methods. A multicast delegate is one that can point to one or more methods that have identical signatures.

Working with Delegates

In essence, a delegate holds a reference to a method and also to the target object on which the method should be called. A delegate in C# is similar to function pointers of C++, but C# delegates are type safe. You can pass methods as parameters to a delegate to allow the delegate to point to the method. Delegates are used to define callback methods and implement event handling, and they are declared using the "delegate" keyword. You can declare a delegate that can appear on its own or even nested inside a class.

There are three steps in using delegates. These include: declaration, instantiation, and invocation. 

The signature of a delegate looks like this:

delegate result-type identifier ([parameters])

The following statement shows how you can declare a delegate.

public delegate void MyDelegate(string text);

As you can see in the above statement, the delegate name is "MyDelegate" can it has a return type of "void" and it accepts a string object as argument. This implies that the delegate MyDelegate can point to a method that has identical signature. This is just a declaration though -- you should always instantiate a delegate before you can use it. The statement given next shows how you can instantiate the delegate declared above.

MyDelegate d = new MyDelegate(ShowText);

Once you have declared and instantiated the delegate, you can invoke the method that the delegate points to easily.

d("Hello World...");

Here, d is the delegate instance

You can also invoke the method that the delegate instance points to using the Invoke() method on the delegate instance as shown below.

d.Invoke("Hello World...");

If you have a method that accepts two numbers and you want to add them and return the sum of the two numbers, you can use a delegate to store the return value of the method as shown in the code snippet given below.

int result = d(12, 15);

Here's the complete code listing for your reference.

using System;

namespace Delegates

{

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

    class Program

    {

      static int Sum(int x, int y)

        {

            return x + y;

        }

        static void Main()

        {

            MyDelegate d = new MyDelegate(Sum);           

            int result = d.Invoke(12, 15);

            Console.WriteLine(result);

            Console.ReadLine();

        }

    }

Delegates in action

Here's the complete code listing.

using System;

namespace Delegates

{

    public delegate void MyDelegate(string text);

    class Program

    {

        public static void ShowText(string text)

        {

            Console.WriteLine(text);

        }

        static void Main()

        {

            MyDelegate d = new MyDelegate(ShowText);

            d("Hello World...");

            Console.ReadLine();

        }

    }

}

Note that you can assign multiple objects to a delegate instance using the + operator, which makes the delegate a multicasting delegate. You can also combine delegate instance using the static method Combine.

The runtime maintains a list (also called Invocation list) internally to execute multiple methods. The following code listing shows how you can use the Combine() method to combine multiple delegate instances.

myDelegate d1 = new myDelegate(Method1);

myDelegate d2 = new myDelegate(Method2);

myDelegate multicastDelegate = (myDelegate)Delegate.Combine(d1, d2);

multicastDelegate.Invoke();

A delegate that can point to multiple methods is known as a multicast delegate. Note that delegate instances are immutable. So, when you combine them or subtract one delegate instance from the list, a new delegate instance is created to represent the updated or new list of the targets or methods to be invoked.

Multicast delegates in action

The following code listing illustrates a multicast delegate. Note the usage of the delegate instance - we have used the += operator to assign the delegate to multiple methods that have identical signature.

using System;

namespace Delegates

{

    public delegate void MyDelegate();

    class Program

    {

        public static void Method1()

        {

            Console.WriteLine("Inside Method1...");

        }

        public static void Method2()

        {

            Console.WriteLine("Inside Method2...");

        }

        static void Main()

        {

            MyDelegate d = null;

            d += Method1;

            d += Method2;

            d.Invoke();

            Console.ReadLine();

        }

    }

}

Delegates are ideally suited to implement event driven programming. A delegate doesn't need to know the class of the object to which it needs to refer to. All it needs to know is the signature of the method to which it would point. Proper usage of delegates can promote code re-usability and flexibility in your designs. You can refer to this MSDN article for more information on delegates.

This article is published as part of the IDG Contributor Network. Want to Join?

To comment on this article and other InfoWorld content, visit InfoWorld's LinkedIn page, Facebook page and Twitter stream.
From CIO: 8 Free Online Courses to Grow Your Tech Skills
Notice to our Readers
We're now using social media to take your comments and feedback. Learn more about this here.