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 Delegatesusing 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 namespublic 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 Methodpublic 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 Delegatesusing System;
class rectangle {
// declaring delegatepublic 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 Methodpublic 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