C# Delegates

The delegate is a reference type data type that defines the method signature. You can define variables of delegate, just like other data type, that can refer to any method with the same signature as the delegate.

There are three steps involved while working with delegates:

  1. Declare a delegate
  2. Create an instance and reference a method
  3. Invoke a delegate

A delegate can be declared using the delegate keyword followed by a function signature, as shown below.

Delegate Syntax
[access modifier] delegate [return type] [delegate name]([parameters])

The following declares a delegate named MyDelegate.

Example: Declare a Delegate
public delegate void MyDelegate(string msg);

Above, we have declared a delegate MyDelegate with a void return type and a string parameter. A delegate can be declared outside of the class or inside the class. Practically, it should be declared out of the class.

After declaring a delegate, we need to set the target method or a lambda expression. We can do it by creating an object of the delegate using the new keyword and passing a method whose signature matches the delegate signature.

Example: Set Delegate Target
public delegate void MyDelegate(string msg); // declare a delegate

// set target method
MyDelegate del = new MyDelegate(MethodA);
// or 
MyDelegate del = MethodA; 
// or set lambda expression 
MyDelegate del = (string msg) =>  Console.WriteLine(msg);

// target method
static void MethodA(string message)
{
    Console.WriteLine(message);
}

You can set the target method by assigning a method directly without creating an object of delegate e.g., MyDelegate del = MethodA.

After setting a target method, a delegate can be invoked using the Invoke() method or using the () operator.

Example: Invoke a Delegate
del.Invoke("Hello World!");
// or 
del("Hello World!");

The following is a full example of a delegate.

Example: Delegate
public delegate void MyDelegate(string msg); //declaring a delegate

class Program
{
    static void Main(string[] args)
    {
        MyDelegate del = ClassA.MethodA;
        del("Hello World");

        del = ClassB.MethodB;
        del("Hello World");

        del = (string msg) => Console.WriteLine("Called lambda expression: " + msg);
        del("Hello World");
    }
}

class ClassA
{
    static void MethodA(string message)
    {
        Console.WriteLine("Called ClassA.MethodA() with parameter: " + message);
    }
}

class ClassB
{
    static void MethodB(string message)
    {
        Console.WriteLine("Called ClassB.MethodB() with parameter: " + message);
    }
}
Try it

The following image illustrates the delegate.

delegate in C#
C# Delegate

Passing Delegate as a Parameter

A method can have a parameter of the delegate type, as shown below.

Example: Delegate
public delegate void MyDelegate(string msg); //declaring a delegate

class Program
{
    static void Main(string[] args)
    {
        MyDelegate del = ClassA.MethodA;
        InvokeDelegate(del);

        del = ClassB.MethodB;
        InvokeDelegate(del);

        del = (string msg) => Console.WriteLine("Called lambda expression: " + msg);
        InvokeDelegate(del);
    }

    static void InvokeDelegate(MyDelegate del) // MyDelegate type parameter
    {
        del("Hello World");
    }
}

class ClassA
{
    static void MethodA(string message)
    {
        Console.WriteLine("Called ClassA.MethodA() with parameter: " + message);
    }
}

class ClassB
{
    static void MethodB(string message)
    {
        Console.WriteLine("Called ClassB.MethodB() with parameter: " + message);
    }
}
Try it
 Note:
In .NET, Func and Action types are built-in generic delegates that should be used for most common delegates instead of creating new custom delegates.

Multicast Delegate

The delegate can point to multiple methods. A delegate that points multiple methods is called a multicast delegate. The "+" or "+=" operator adds a function to the invocation list, and the "-" and "-=" operator removes it.

Example: Multicast Delegate
public delegate void MyDelegate(string msg); //declaring a delegate

class Program
{
    static void Main(string[] args)
    {
        MyDelegate del1 = ClassA.MethodA;
        MyDelegate del2 = ClassB.MethodB;

        MyDelegate del = del1 + del2; // combines del1 + del2
        del("Hello World");

        MyDelegate del3 = (string msg) => Console.WriteLine("Called lambda expression: " + msg);
        del += del3; // combines del1 + del2 + del3
        del("Hello World");

        del = del - del2; // removes del2
        del("Hello World");

        del -= del1 // removes del1
        del("Hello World");
    }
}

class ClassA
{
    static void MethodA(string message)
    {
        Console.WriteLine("Called ClassA.MethodA() with parameter: " + message);
    }
}

class ClassB
{
    static void MethodB(string message)
    {
        Console.WriteLine("Called ClassB.MethodB() with parameter: " + message);
    }
}
Try it

The addition and subtraction operators always work as part of the assignment: del1 += del2; is exactly equivalent to del1 = del1+del2; and likewise for subtraction.

If a delegate returns a value, then the last assigned target method's value will be return when a multicast delegate called.

Example: Multicast Delegate Returning a Value
public delegate int MyDelegate(); //declaring a delegate

class Program
{
    static void Main(string[] args)
    {
        MyDelegate del1 = ClassA.MethodA;
        MyDelegate del2 = ClassB.MethodB;

        MyDelegate del = del1 + del2; 
        Console.WriteLine(del());// returns 200
    }
}

class ClassA
{
    static int MethodA()
    {
        return 100;
    }
}

class ClassB
{
    static int MethodB()
    {
        return 200;
    }
}
Try it

Generic Delegate

A generic delegate can be defined the same way as a delegate but using generic type parameters or return type. The generic type must be specified when you set a target method.

For example, consider the following generic delegate that is used for int and string parameters.

Example: Generic Delegate
public delegate T add<T>(T param1, T param2); // generic delegate

class Program
{
    static void Main(string[] args)
    {
        add<int> sum = Sum;
        Console.WriteLine(sum(10, 20));

        add<string> con = Concat;
        Console.WriteLine(conct("Hello ","World!!"));
    }

    public static int Sum(int val1, int val2)
    {
        return val1 + val2;
    }

    public static string Concat(string str1, string str2)
    {
        return str1 + str2;
    }
}
Try it

1. Func Delegates:  Tutorial Link

2. Action Delegates: Tutorial Link

3. Predicate Delegates: Tutorial Link

Delegate is also used to declare an Event and an Anonymous Method.

 Points to Remember :
  1. Delegate is the reference type data type that defines the signature.
  2. Delegate type variable can refer to any method with the same signature as the delegate.
  3. Syntax: [access modifier] delegate [return type] [delegate name]([parameters])
  4. A target method's signature must match with delegate signature.
  5. Delegates can be invoke like a normal function or Invoke() method.
  6. Multiple methods can be assigned to the delegate using "+" or "+=" operator and removed using "-" or "-=" operator. It is called multicast delegate.
  7. If a multicast delegate returns a value then it returns the value from the last assigned target method.
  8. Delegate is used to declare an event and anonymous methods in C#.

Comments

Post a Comment

Popular posts from this blog

C# Keywords

C# contains reserved words that have special meaning for the compiler these reserved words are called "keywords" keywords can't be used as identifier (name of variable, class, interface etc) there are 11 types of keywords. 1. Modifier Keywords  2. Access Modifier Keywords  3. Statement Keywords  4. Method Parameter Keywords  5. Namespace Keywords  6. Operator Keywords  7. Access Keywords  8. Literal Keywords  9. Type Keywords  10. Contextual Keywords  11. Query Keywords  1. Modifier Keywords : are the specific keywords that indicates which can modify types and type members. Example - Abstract, async, const, event, extern, new, override, partial, read-only, sealed, static, unsafe, virtual and volatile.  2. Access Modifier Keywords: are applied to the declaration of the class, methods, properties, fields and other member. they define the accessibility of the class and its members. there are basic four type of Access Modifier...
Read more

C# Extension Method

Image
It is a new feature that has been added in C# 3.0 which allows us to add new methods into a class without editing the source code of the class i.e. if a class consists of a set of members in it and in the future if you want to add new methods into the class, you can add those methods without making any changes to the source code of the class. Extension methods can be used as an approach to extending the functionality of a class in the future if the source code of the class is not available or we don’t have any permission in making changes to the class. Before extension methods, inheritance is an approach that is used for extending the functionality of a class i.e. if we want to add any new members to an existing class without making a modification to the class, we will define a child class to that existing class and then we add new members in the child class. In the case of an extension method, we will extend the functionality of an existing class. In this case, we will create a new cl...
Read more

C# Ref and Out Keywords

Ref - Ref is two ways from caller to callee and back.  static void Main(string[] args)         {             int outSideVar = 10;             GetNextNameByOut(out outSideVar);              Console.WriteLine(outSideVar);         }         static void GetNextNameByOut(out int inSideVar)         {             inSideVar = inSideVar + 20;         }  Out - Data sent from the caller has been discarded and its mandatory to initialize the variables inside the callee.  Out is a ne way from callee to caller.  static void Main(string[] args)      ...
Read more