Explaining the Delegates Concept !

Delegates are the type that defines a method signature, and can hold a reference to one or more methods with that signature.
They are often described or called as a Type-Safe function pointers because they allow methods to be passed as a parameter, assigned to variable, or invoke dynamically all while ensuring type-safe..🔒

What are the Key Points of the Delegates 🗝️ ?

• Method Signature : A delegate specifies return type and the parameters of the method it can refer to.

• Type-Safe : Delegates ensures that the method they reference has the correct signature.

• Multicast : A single delegate can reference multiple methods and invoke them sequentially. This is known as multicast delegate.

• Encapsulation : Delegates encapsulates the methods and it's behavior making them useful for defining callback mechanism.

So what is the Syntax of Delegates ?!

// 1. Declare a Delegate.. public delegate void MyDelegate(string message); // 2. Create a method matching the Delegate's signature public class Program { public static void DisplayMessage(string message) { Console.WriteLine(message); } public static void Main() { // 3. Instantiate the delegate MyDelegate del = DisplayMessage; // 4. Invoke the delegate del("Hellow, World!"); } } 

Let's talk about the common uses !
There are 3 common uses :

1. Event Handling
2. Callback mechanism
3. LINQ and Functional programming

Let's explain them one by one

1- Event Handling : Delegate are the foundation of events in C#, They allow subscribing and unsubscribing to events using methods.

public delegate void Notify(); public class EventExample { public event Notify OnNotify; public void TriggerEvent() { OnNotify?.Invoke(); // Safely invoke the delegates if it has subscribers  } } 

2- Callback mechanism : Passing a method to another method to be executed later.

public class Calculator { public void PerformOperation(int x, int y, Action<int> callback) { int result = x + y; callback(result); } } public class Program { public static void Main() { Calculator calc = new (); calc.PerformOperation(2, 3, Console.WriteLine); // Pass Console.WriteLine as a Delegate } } 

3- LINQ and Functional Programming : Delegates like Func, Action, Predicate are heavily used in LINQ to define custom logic.

What are the built-in Delegates ??

1. Action : Represents method with no return value but with parameters.

Action<string> print = Console.WriteLine; print("Hello, World!"); 

1. Func : Represents a method with a return value and parameter.

Func<int, int, int> add (x,y) => x + y; Console.WriteLine(add(3,4)); 

1. Predicate : Represents a method that return bool and it takes a single parameter.

Predicate<int> IsEven = x => x % 2 == 0; Console.WriteLIne(IsEven(4)); 

Advantages of Delegates

• Flexibility => Enables dynamic methods invokation

• Loose Coupling => Promotes code extensibility by allowing methods to be assigned dynamically

• Reuseability => Encourages creating modular and reuseable code

That's it for now! Keep coding and stay awesome. Catch you later Nerds!