Overview Of Delegate Concept In C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ArrayOfDelegateInstances
{
    class DemoApp
    {
        public delegate int ArithOp(int x, int y);
        class MathOps
        {
            public static int Add(int a, int b)
            {
                return a + b;
            }
            public static int Mul(int a, int b)
            {
                return a * b;
            }
            public static void ProcessMethod(ArithOp operation, int c, int d)
            {
                int result = operation(c, d);
                Console.WriteLine("Result: " + result);
            }
        }
        static void Main(string[] args)
        {
            ArithOp[] operations = 
            {
                new ArithOp(MathOps.Add),
                new ArithOp(MathOps.Mul)
            };
            MathOps.ProcessMethod(operations[0], 22, 33);
            Console.Read();
        }
    }
}

Explanation

In the program given above.

• The line given below indicates how to create an array of delegate instances.

  ArithOp[] operation = {
      new ArithOp(MathOps.Add), 
      new ArithOp(MathOps.Mul)
  };
  

• Now, let us try to understand, how to invoke the delegate method from this array.
• The code line given below indicates how to invoke the delegate method from this array.

  MathOps.ProcessMethod(operation[0], 22, 33);
  

Here, it invokes the Add method.

Observe, the output of the program given above is given below.

Addition 55M

Now, we will look into it.

Multicast delegates

In this, first of all, we will see Multicast delegate with void return types. The code snippet is given below for it.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// Sandip Patil DemoApp
namespace VoidMulticastDelegate
{
    class MyProgVoidMulticastDelegate
    {
        public delegate void Mdelegate();
        class MathOps
        {
            public static void M1()
            {
                Console.WriteLine("M1");
            }
            public static void M2()
            {
                Console.WriteLine("M2");
            }
        }
        static void Main(string[] args)
        {
            Mdelegate k1 = new Mdelegate(MathOps.M1);
            Mdelegate k2 = new Mdelegate(MathOps.M2);
            Mdelegate k3 = k1 + k2;
            k3();
            Console.Read();
        }
    }
}

Explanation

In the program given above.

• M1 and M2 are both delegate methods with void return types.
• The code lines given below indicate that M1 and M2 are encapsulated into k1 and k2.

  Mdelegate k1 = new Mdelegate(MathOps.M1);
  Mdelegate k2 = new Mdelegate(MathOps.M2);
  

• The line given below indicates that k3 is a delegate instance with M1 and M2 is encapsulated into it.

  Mdelegate k3 = k1 + k2;
  

• Now, let’s see how to invoke multicast delegate.
• The code line given below demonstrates it.

  k3();
  

Here, it invokes both M1 and M2 Method at a time in a single call i.e. k3 has more than one method in its invocation list.

Observe the output of the program given above is shown below.

M1
M2

Let us see,

Multicast delegate with Non-void return types

The code snippet is given below for it.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
// sandip patil DemoApp
namespace nonVoidMulticast
{
    class Program
    {
        public delegate int Fun<T>();
        class MathsOp
        {
            public static int M1()
            {
                Console.WriteLine("M1");
                return 1;
            }
            public static int M2()
            {
                Console.WriteLine("M2");
                return 2;
            }
        }
        static void Main(string[] args)
        {
            Fun<int> d1 = MathsOp.M1;
            Fun<int> d2 = MathsOp.M2;
            Fun<int> d = d1 + d2;
            foreach (Fun<int> i in d.GetInvocationList())
            {
                int r = i();
                Console.WriteLine("" + r);
            }
            Console.Read();
        }
    }
}

Explanation

In the program given above.

• Observe the delegate declaration for non-void return type and the code line given below demonstrates it.

  public delegate int Fun<T>();
  

• A function template is used here.
• Observe how delegate is instantiated and the code line given below demonstrates it.

  Fun<int> d1 = MathsOp.M1;
  

• Now, observe the code given below.

  Fun<int> d = d1 + d2;
  

• Here both methods are encapsulated.
• Important point is =>in order to invoke Multicast delegate with non-void return type, we need to use the GetInvocationList() Method.
• The code snippet given below demonstrates it.

  foreach (Fun<int> i in d.GetInvocationList()) 
  {
      int r = i();
      Console.WriteLine("" + r);
  }
  

Observe the output of the program given above is shown below.

M1
1
M2
2