Delegates

Methods are delegate types. It is that simple. Since delegates are types in .NET we can use any method as types, that means we can pass methods as parameters and we can return methods.

The below code shows different ways we can instantiate a delegate.

namespace DelegatesVsInterfaces
{
    public delegate string MyDelegate(string param);
 
    class Program
    {
        static void Main(string[] args)
        {
            // delegate initialization based on history
            
            // C# 1.0
            MyDelegate md1 = new MyDelegate(MyMethod);
            Console.WriteLine(md1("C# 1.0"));
 
            // C# 2.0
            MyDelegate md2 = MyMethod;
            Console.WriteLine(md2("C# 2.0"));
 
            // C# 2.0 - anonymous method
            MyDelegate md3 = delegate(string message) 
            { 
                return String.Format("Your message, {0} - from anonymous method",message); 
            };
            Console.WriteLine(md3("C# 2.0 and later"));
 
            // C# 3.0 - lamda expressions
            MyDelegate md4 = message => 
            { 
                return String.Format("Your message, {0} - from lamda methods", message); 
            };
            Console.WriteLine(md4("C# 3.0 and later"));
 
            Console.ReadKey();
        }
 
       public static string MyMethod(string greeting)
       {
           //Thread.Sleep(5000);
           return String.Format("Your message, {0} - relayed from MyMethod",greeting);
       }
   }
}

A delegate has different ways of invocation. The very direct way is calling the delegate itself with the parameters. This indirectly invokes the Invoke() method of the delegate. Invoke() is generated by the compiler with the correct parameter list.

The following code shows the direct invocation.

   1: string result = md1("parameter");
   2: result = md1.Invoke("parameter");

Other way of handling a delegate invocation is, invoking the method asynchronously. BeginInvoke() and EndInvoke() of a delegate is used for this.

BeginInvoke() is generated for a delegate with that specific delegate’s parameters as first set of parameters, next parameter is a AsyncCallback type method and last one is a object which could have values to the callback method.

The following code explains how to use the BeginInvoke() and EndInvoke() to asynchronous execution.

// put this in your method invocation code
MyDelegate md = MyMethod;
AsyncCallback callback = CallBackMethod;
 
IAsyncResult result = md.BeginInvoke("Param", callback, null);
 
 
// callback method
public static void CallBackMethod(IAsyncResult result)
{
    AsyncResult asyncResult = (AsyncResult)result;
    MyDelegate caller = (MyDelegate)asyncResult.AsyncDelegate;
    
    string value = caller.EndInvoke(result);
 
    Console.WriteLine(value);
}

If the method hasn’t finished the execution when the EndInvoke() is called, the callback method waits till the execution is finished.

Another way of invoking a delegate is by using its DynamicInvoke(). More often this is direct as Invoke(), but has the difference in the parameters passed to the delegate. DynamicInvoke() has a object array parameter. We should pass the parameters with the correct data types and it should be with the correct parameter count. If the parameter is not correct it will throw an ArgumentException and if the number of parameters doesn’t match it will throw TargetParameterCountException.

Share this:

Related