Overview Of Delegates

Delegate

"A delegate is similar to a pointer function in C or C++ that holds reference of a method. It allows to encapsulate reference to a method inside a delegate object .The delegate object can be passed to a code which can call the reference method."

You often read such definitions about delegates, this is true but incomplete.The real purpose of a Delegate is to communicate. As 'delegate' is a English language word and the meaning of this word is to represent or communicate between/among communities, classes, etc.

So the delegate are for communication. We use delegate when one class want to communicate with other class. Of course there are several other ways of doing that, but we should adopt the best way to do any thing.

Why we use Delegate

C# does not allow us passing method reference directly as arguments to other methods, rather it provides delegates.

For example, you write a Class (of code). In this Class you wrote a method. A second person working in your team or elsewhere needs this method which you have written in your class. You would provide delegate to that person so that he/she can call this method.

Delegates are especially useful in event driven environment such as Graphical User Interface(GUI) in which you want that code to execute when user clicks the button.

Note: Delegates are classes that encapsulate set of references to method.

There are two types of delegate:

1. Single Cast Delegate
2. Multi Cast Delegate

See the detail of both in later section:

Single Cast Delegate

A delegate that contains a single method is known as Single Cast delegate. And it is derived from the class Delegate.

Multi Cast Delegate

A delegate that contains multiple methods are Multi Cast Delegate.

Both Single Cast Delegate and Multi Cast Delegate belong to Namespace System.

Before using delegates the following point must be considered:

"The method header (Parameter & return value) of a delegate and the method whose reference will be within a delegate object must have same method header."

Let us proceed to some practical examples.

There are the following steps involved in using Delegates:

1. Declaration
2. Instantiation
3. Invocation

Example 1: A simple Delegate

using System;
namespace Simple.Delegate
{
    // Step 1:Declaration
    public delegate void SimpleDelegate();
    class MyClass
    {
        public static void Print()
        {
            Console.WriteLine("Delegate was Printed");
        }
        public static void Main()
        {
            // Step 2:Instantiation
            SimpleDelegate simpleDelegate = new SimpleDelegate(Print);
            // Step 3: Invocation
            simpleDelegate();
        }
    }
}

Multi Cast Delegate

"A delegate that contains multiple methods are Multi Cast Delegate.".

We use multi cast delegate when there is need of invoking multiple events like we want to print a string and at the same time we want to write this string in the file or that purpose we use multi cast delegate.

Note: These events are invoked in which sequence you called them. For example, there are two events print and read. The order in which read and print would be invoked depends upon the order in which you would call them (events).

Example 1

// Class 1
class Name
{
    public void Print()
    {
        Console.WriteLine("My Name is Usman Arshad");
    }
}
//Class 2
class Country
{
    public void Print()
    {
        Console.WriteLine("I am from Pakistan");
    }
}
//Main Class
namespace
{
    public delegate void Multicastdelegate();
    class Program
    {
        Name obj = new Name();
        Country obj1 = new Country();
        Multicastdelegate delegate = new Multicastdelegate(obj.Print); //Reference of the print method of class Name
        delegate = delegate + new Multicastdelegate(obj1.Print); //Just use '+' sign to add more methods
        obj1.Invoke();
    }
}

Decoupling

Delegates also promote decoupling (It is an Object oriented concept, I will write about that later).

For example, you have written a class of Calculator in which you have written the methods of Addition, Subtraction, Multiplication and Division. Another class is using your methods. You add some more methods in your class, in order to use these methods you also need to change your class.

Delegates provides solution to this problem.

Let us go through an example.

This is a calculator class which takes inputs and perform Addition, Subtraction, Multiplication and Division operations and return result.

namespace Delegates
{
    delegate int Mathoperation(int num1, int num2); //Delegate declaration
    class Calculator
    {
        public Mathoperation GetOperation(int option)
            {
                Mathoperation mathOperation = null; //Currently, delegate object has no reference
                if (option == 1)
                {
                    mathOperation = Add;
                }
                else if (option == 2)
                {
                    mathOperation = Sub;
                }
                else if (option == 3)
                {
                    mathOperation = Div;
                }
                else if (option == 4)
                {
                    mathOperation = Mul;
                }
                else
                {
                    Console.WriteLine("You choose the wrong option");
                }
                return mathOperation;
            }
            //Mathematical Operations
        private int Add(int num1, int num2)
        {
            return num1 + num2;
        }
        private int Sub(int num1, int num2)
        {
            return num1 - num2;
        }
        private int Div(int num1, int num2)
        {
            return num1 / num2;
        }
        private int Mul(int num1, int num2)
        {
            return num1 * num2;
        }
    }
}

Here's a class which is using the above class methods.

class Program
{
    static void Main(string[] args)
    {
        This is a class which is using these methods.
        Console.WriteLine("Enter the Option");
        Console.WriteLine("1.Addition");
        Console.WriteLine("2.Subtraction");
        Console.WriteLine("3.Division");
        Console.WriteLine("4.Multiplication");
        int option = int.Parse(Console.ReadLine());
        Calculator Cal_obj = new Calculator();
        int result = Cal_obj.GetOperation(option)
            .Invoke(10, 20);
        Console.WriteLine(result);
    }
}

Now whatever changes you made in your Calculator class, It would not affect your Program Class which is using the methods of this class.

This is called decoupling and Object Oriented Method encourages decoupling.