Delegates in C#

Delegates can be used to hold the reference of method. A delegate is a type that safety encapsulates a method and it is similar to function pointer in C and C++. Delegates can be used to define call back methods. Delegate class hold only those methods which have same signature. It allow methods to be passed as parameters. A delegate can be seen as a placeholder for method. Delegates can be chained multiple methods together and can be called on a single event.

Suppose if you have multiple methods with same signature which have same return type & number of parameters and want to call all the methods with single object then we can go for delegates.

Creating and using delegates involve the four steps:

1. Declaring a delegate
2. Defining a delegate method
3. Creating delegate object
4. Invoking delegate object

class Program
{
    // Step-1. Declaring a delegates
    // Access modifier - delegate keyword - return type - delegate-name
    public delegate void Calculate(int a, int b); 

    // Step-2. Defining a delegate method
    // Signature of method exactly matches the delegate signature.
    public static void Add(int x, int y)
    {
        Console.WriteLine("Sum = {0}", x + y);
    } 

    static void Main(string [] args)
    {
        // Step-3. Creating delegate object
        Calculate calculate = new Calculate(Add);

        // Step-4. Invoking delegate object
        calculate(5, 5);

        Console.ReadKey();
    }      
}

You can also assign any method to delegates like :

// Step-3. Creating delegate object
Calculate calculate = Add;

Types of Delegates

1. Single cast delegate

Delegate that represent only a single method is known as Single Cast Delegate.

class Program
{
    //  Declaring a delegates      
    public delegate void Calculate(int a, int b); 

    // Defining a delegate method     
    public static void Add(int x, int y)
    {
        Console.WriteLine("Sum = {0}", x + y);
    } 

    static void Main(string [] args)
    {
        // Creating delegate object
        Calculate calculate = new Calculate(Add);

        // Invoking delegate object
        calculate(5, 5);
        Console.ReadKey();
    }      
}

2. Multi Cast Delegate

Delegate that represent more than one method is known as Multi Cast Delegate.

Use += operator to add reference of a method to delegate

Use -= operator to remove reference of a method

class Program
{
    // Declaring a delegates     
    public delegate void Calculate(int a, int b);

    // Defining a delegate method     
    public static void Add(int x, int y)
    {
        Console.WriteLine("Sum = {0}", x + y);
    } 

    // Defining second delegate method
    public static void Multiply(int x, int y)
    {
        Console.WriteLine("Multiply = {0}", x + y);
    }  

    static void Main(string [] args)
    {
        // Creating delegate object
        Calculate calculate = new Calculate(Add);

        // Add second method to delegate
        calculate += Multiply; 

        // Invoking delegate object, it will call Add and Multiply both method
        calculate(5, 5);

        Console.ReadKey();
    }
}

You can also create separate delegate object for each method and combine all objects to a single to perform Multicast delegate.

// Alternate way of creating Multicast delegate object
Calculate delegate1 = Add;
Calculate delegate2 = Multiply;
Calculate calculate = delegate1 + delegate2;

Remove reference of a method from Multicast delegate object.

static void Main(string [] args)
{
    //Creating delegate object
    Calculate calculate = new Calculate(Add);

    // add second method to delegate
    calculate += Multiply;

    // Remove reference of Add method to delegate
    calculate -= Add;

    // Invoking delegate object, it will call only Multiply method
    calculate(5, 5);

    Console.ReadKey();
} 

// Output
// Multiply = 10