C# | Delegates

A delegate is an object which refers to a method or you can say it is a reference type variable that can hold a reference to the methods. Delegates in C# are similar to the function pointer in C/C++. It provides a way which tells which method is to be called when an event is triggered. 
For example, if you click on a Button on a form (Windows Form application), the program would call a specific method. In simple words, it is a type that represents references to methods with a particular parameter list and return type and then calls the method in a program for execution when it is needed.

Important Points About Delegates:

• Provides a good way to encapsulate the methods.
• Delegates are the library class in System namespace.
• These are the type-safe pointer of any method.
• Delegates are mainly used in implementing the call-back methods and events.
• Delegates can be chained together as two or more methods can be called on a single event.
• It doesn’t care about the class of the object that it references.
• Delegates can also be used in “anonymous methods” invocation.
• Anonymous Methods(C# 2.0) and Lambda expressions(C# 3.0) are compiled to delegate types in certain contexts. Sometimes, these features together are known as anonymous functions.

Declaration of Delegates

Delegate type can be declared using the delegate keyword. Once a delegate is declared, delegate instance will refer and call those methods whose return type and parameter-list matches with the delegate declaration.

Syntax: 

[modifier] delegate [return_type] [delegate_name] ([parameter_list]);

modifier: It is the required modifier which defines the access of delegate and it is optional to use.
delegate: It is the keyword which is used to define the delegate.
return_type: It is the type of value returned by the methods which the delegate will be going to call. It can be void. A method must have the same return type as the delegate.
delegate_name: It is the user-defined name or identifier for the delegate.
parameter_list: This contains the parameters which are required by the method when called through the delegate. 

Example

// 'public' is the modifier
// 'int' is return type
// 'GeeksForGeeks' is delegate name
// '(int G, int F, int G)' are the parameters
public delegate int GeeksForGeeks(int G, int F, int G);

Note: A delegate will call only a method which agrees with its signature and return type. A method can be a static method associated with a class or can be an instance method associated with an object, it doesn’t matter. 
 

Instantiation & Invocation of Delegates

After declaring a delegate, a delegate object is created with the help of new keyword. Once a delegate is instantiated, a method call made to the delegate is pass by the delegate to that method. The parameters passed to the delegate by the caller are passed to the method, and the return value, if any, from the method, is returned to the caller by the delegate. This is known as invoking the delegate. 

Syntax:

[delegate_name]  [instance_name] = new [delegate_name](calling_method_name);

Example

GeeksForGeeks GFG = new GeeksForGeeks (Geeks);
       // here,
       // 'GeeksForGeeks' is delegate name. 
       // 'GFG' is instance_name
       // 'Geeks' is the calling method.

Below program illustrate the use of Delegate -

// C# program to illustrate the use of Delegates
using System;
namespace GeeksForGeeks {

// declare class 'Geeks'
class Geeks {

// Declaring the delegates
// Here return type and parameter type should
// be same as the return type and parameter type
// of the two methods
// 'addnum' and 'subnum' are two delegate names
public delegate void addnum(int a, int b);
public delegate void subnum(int a, int b);

// method 'sum'
public void sum(int a, int b)
{
 Console.WriteLine('(100 + 40) = {0}', a + b);
}
// method 'subtract'
public void subtract(int a, int b)
{
 Console.WriteLine('(100 - 60) = {0}', a - b);
}
// Main Method
public static void Main(String []args)
{

// creating object 'obj' of class 'Geeks'
Geeks obj = new Geeks();
// creating object of delegate, name as 'del_obj1'
// for method 'sum' and 'del_obj2' for method 'subtract' &
// pass the parameter as the two methods by class object 'obj'
// instantiating the delegates
addnum del_obj1 = new addnum(obj.sum);
subnum del_obj2 = new subnum(obj.subtract);
// pass the values to the methods by delegate object
del_obj1(100, 40);
del_obj2(100, 60);
// These can be written as using
// 'Invoke' method
// del_obj1.Invoke(100, 40);
// del_obj2.Invoke(100, 60);
}
}
}

Output

(100 + 40) = 140

(100 - 60) = 40

Explanation: In the above program, there are two delegates addnum and subnum. We are creating the object obj of the class Geeks because both the methods(addnum and subnum) are instance methods. So they need an object to call. If methods are static then there is no need to create the object of the class.
 

Multicasting of a Delegate

Multicasting of delegate is an extension of the normal delegate(sometimes termed as Single Cast Delegate). It helps the user to point more than one method in a single call.

Properties

• Delegates are combined and when you call a delegate then a complete list of methods is called.
• All methods are called in First in First Out(FIFO) order.
• ‘+’ or ‘+=’ Operator is used to add the methods to delegates.
• ‘–’ or ‘-=’ Operator is used to remove the methods from the delegates list.

Note: Remember, multicasting of delegate should have a return type of Void otherwise it will throw a runtime exception. Also, the multicasting of delegate will return the value only from the last method added in the multicast. Although, the other methods will be executed successfully.

Below program demonstrates the use of Multicasting of a delegate -

// C# program to illustrate the
// Multicasting of Delegates
using System;

class rectangle {
	
// declaring delegate
public delegate void rectDelegate(double height,
								double width);

	// 'area' method
	public void area(double height, double width)
	{
		Console.WriteLine('Area is: {0}', (width * height));
	}

	// 'perimeter' method
	public void perimeter(double height, double width)
	{
		Console.WriteLine('Perimeter is: {0} ', 2 * (width + height));
	}


// Main Method
public static void Main(String []args)
{
	
	// creating object of class
	// 'rectangle', named as 'rect'
	rectangle rect = new rectangle();

	// these two lines are normal calling
	// of that two methods
	// rect.area(6.3, 4.2);
	// rect.perimeter(6.3, 4.2);

	// creating delegate object, name as 'rectdele'
	// and pass the method as parameter by
	// class object 'rect'
	rectDelegate rectdele = new rectDelegate(rect.area);
	
	// also can be written as
	// rectDelegate rectdele = rect.area;

	// call 2nd method 'perimeter'
	// Multicasting
	rectdele += rect.perimeter;

	// pass the values in two method
	// by using 'Invoke' method
	rectdele.Invoke(6.3, 4.2);
	Console.WriteLine();
	
	// call the methods with
	// different values
	rectdele.Invoke(16.3, 10.3);
}
}

Output: 
Area is: 26.46 Perimeter is: 21 

Area is: 167.89 Perimeter is: 53.2 

1. Delegates are similar to C++ function pointers, but are type safe.
2. Delegates allow methods to be passed as parameters.
3. Delegates can be used to define callback methods.
4. Delegates can be chained together; for example, multiple methods can be called on a single event.
5. Methods don't need to match the delegate signature exactly.
6. Using a delegate allows the programmer to encapsulate a reference to a method inside a delegate object. The delegate object can then be passed to code that can call the referenced method, without having to know at compile time which method will be invoked.
7. An interesting and useful property of a delegate is that it does not know or care about the class of the object that it references.
8. In delegate add and subtract (+ or -) on function. In other word delegate that hold the more than on method.

Delegation in C# has two type