A delegate (known as function pointer in C/C++) is a references type that invokes single/multiple method(s) through the delegate instance. It holds a reference of the methods. Delegate types are sealed and immutable type.
A delegate provides a way to encapsulate a method. Delegate type as being a bit like an interface with a single method. It specifies the signature of a method, and when you have a delegate instance, you can make a call to it as if it were a method with the same signature.
A delegate is a C# language element that allows you to reference a method. If you were a C or C++ programmer, this would sound familiar because a delegate is basically a function pointer. However, developers who have used other languages are probably wondering, "Why do I need a reference to a method?". The answer boils down to giving you maximum flexibility to implement any functionality you want at runtime.
When you instantiate a delegate, you can associate its instance with any method with a compatible signature and return type. You can invoke (or call) the method through the delegate instance.
Delegates have the following properties:
- Delegates are like C++ function pointers but are type safe.
- Delegates allow methods to be passed as parameters.
- Delegates can be used to define callback methods.
- Delegates can be chained together; for example, multiple methods can be called on a single event.
- Methods do not have to match the delegate type exactly
- C# version 2.0 introduced the concept of Anonymous Methods, which allow code blocks to be passed as parameters in place of a separately defined method. C# 3.0 introduced lambda expressions as a more concise way of writing inline code blocks. Both anonymous methods and lambda expressions (in certain contexts) are compiled to delegate types. Together, these features are now known as anonymous functions.
There are three types of delegates that can be used in C#.
- Single Delegate
- Multicast Delegate
- Generic Delegate
Scenarios where can be used
· Handle (call/invoke) multiple methods on a single event.
· Define callback (asynchronous) methods.
· Decoupling and implementing generic behaviors.
· Invoke method at run time.
· In LINQ for parsing the Expression Tree.
Syntax of Delegates
delegate <return type> <delegate-name> <parameter list>
public delegate int MyDelegate (string s);
//Declare delegate outside the class
public delegate void mydelegate(int x, int y);
//Declare a custom event
public static event mydelegate myevent;
public static void sum(int x, int y)
Console.WriteLine("Sum " + (x + y));
public static void diff(int x, int y)
Console.WriteLine("Diff " + (x - y));
public static void RaiseEvent(int x, int y)
if (myevent != null)
static void Main(string args)
//Instantiate delegate by passing a method name
mydelegate del = new mydelegate(MyClass.sum);
//attaching a method to delegate
del += MyClass.diff;
//As the above delegate holds reference of 2 methods ,
//it is called as multicast delegate
//calling a delegate
// alternate way to invoke a delegate
//attaching a delegate to event
MyClass.myevent += del;
Post a Comment