Tuesday, 24 September 2013

Delegates - C Sharp


Delegate is a reference type that holds the reference of a class method. Any method which has the same signature as delegate can be assigned to delegate. Delegate is like function pointer in C++. There are three aspects to a delegate: Declaration, Instantiation and Invocation.


Declaration:

A delegate is declared by using the keyword delegate, otherwise it resembles a method declaration.

delegate int delegateAdd(int x, int y);

Instantiation:
To create a delegate instance, we need to assign a method (which has same signature as delegate) to delegate.

        static int add(int a, int b)
        { 
          return a + b; 
        }

        //create delegate instance
        delegateAdd objAdd = new delegateAdd(Add);

        //short hand for above statement
        delegateAdd objAdd = Add;

Invocation:
Invoking a delegate is like as invoking a regular method.

        // Invoke delegate to call method
        int result = objAdd.Invoke(3, 6);

        //short hand for above statement
        int result = objAdd(3, 6); 




 Complete Code is:

 class Program
    {
        delegate int delegateAdd(int x, int y);

        static int add(int a, int b)
        { return a + b; }

        static void Main(string[] args)
        {
           // Program p = new Program();
           //delegateAdd _del = p.add;

            delegateAdd _del = add;
            int result = _del.Invoke(3, 6);
            Console.Write(result);
            Console.Read();
        }
    }

Output will be :
9



Type of Delegate

Delegates are one of two types:
  1. Singlecast Delegate
  2. Multicast Delegate
Singlecast DelegateA Singlecast delegate is derived from the System.Delegate class. It can contain a reference for one method at a time. In the above example the delegate uses a Singlecast delegate.

Multicast DelegateA Multicast delegate is derived from the System.MulticastDelegate class. It can contain references for multiple methods. For understanding multicast delegates you can consider the real-life example: of a Coffee vending machine.

A Coffee vending machine has three containers for Milk, Coffee, and Tea. If you press the Tea button then there will two containers, Milk and Tea that work together. And if you press the button for Coffee then the Milk and Coffee containers will work. So if you want to call multiple functions then you can use a multicast delegate.

using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;
namespace Anonymous
{
    
class Class1    {
        
public delegate void Vender();
        public static void Milk()
        {
            
Console.Write("Milk + ");
        }
 
        
public static void Tea()
        {
            
Console.Write("Tea = Tea ");
        }
 
        
public static void Coffee()
        {
            
Console.Write("Coffee = Coffee ");
        }
        static void Main()
        {
            
Vender vender = new Vender(Milk);
            
Console.WriteLine("\t\tPress 1 For Tea\n\t\t Press 2 For Coffee");
            
int Opt = Convert.ToInt32(Console.ReadLine());
            
switch (Opt)
            {
                
case 1:
                    vender += Tea;
                    
break;
                case 2:
                    vender += Coffee;
                    
break;
                default:
                    
Console.WriteLine("Invalid Option !");
                    
Environment.Exit(0);
                    
break;
            }
            vender();
            
Console.ReadKey();
        }
    }
}
In the above program I just created the three functions, Tea, Coffee and Milk. When one is pressed there will be two functions, called Milk and Tea. If the user chooses both then again the two functions, Milk and Coffee are called. Since Milk is common to both situations I just pass Milk in the Delegate parameter. And the delegate understands "+" and "+=" for adding references of functions and "-" and "-=" for removing function references, so dependng on the option used I just add a function reference with the same Delegate obeject vender. And invoke the delegate vender.



Anonymous MethodIn C# 1.0 you can use a delegate and pass a function reference with an initializing delegate with a function name, but C# 2.0 introduced anonymous functions.

Creating an anonymous method as an inline block of code to be passed as a delegate parameter can be done as you see in the following:
using System;using System.Collections.Generic;using System.Linq;

using System.Text;
using System.Threading.Tasks;
namespace Anonymous
{
    
class Class1    {
        
public delegate void Del();
        static void Main(string[] args)
        {
            
Del obj = delegate() {
                
Console.WriteLine"Class1.fun");
            };
            obj();
        }
    }
}

Use of an anonymous function can reduce the lines of code. So, here in the program above you can see I just passed a block of code for a delegate parameter inside of creating a function anywhere else and passing the function name. The anonymous function uses the delegate keyword while delegate initialization writes a block of code. You can also pass a parameter for an anonymous function as follows:
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;
namespace Anonymous
{
    
class Class1    {
        
public delegate void Delstring Mesg);
        static void Main(string[] args)
        {
            
Del obj = delegate(string Mesg) {
                
Console.WriteLine(Mesg);
            };
            obj("Class1.fun");
        }
    }
}
Note:
You cannot use goto, break and continue statements inside the anonymous method block if the targat is outside an anonymous block.

1 comment:

Topics

ADO .Net (2) Ajax (1) Angular Js (17) Angular2 (24) ASP .Net (14) Azure (1) Breeze.js (1) C# (49) CloudComputing (1) CMS (1) CSS (2) Design_Pattern (3) DI (3) Dotnet (21) Entity Framework (3) ExpressJS (4) Html (3) IIS (1) Javascript (6) Jquery (9) Lamda (3) Linq (11) Mongodb (1) MVC (48) NodeJS (7) RDLC (1) Report (1) Sql Server (29) SSIS (3) SSRS (2) UI (1) WCF (12) Web Api (9) Web Service (1) XMl (1)