C# Delegates

Delegates in C# are powerful constructs that enable methods to be passed as parameters, stored as variables, and used to define callback methods. They are fundamental to implementing events, asynchronous programming, and designing flexible and reusable code. This comprehensive guide explores delegates in C# in depth, covering their declaration, usage, advanced features, and best practices with detailed explanations and code examples.

Table of Contents

1. Introduction to Delegates
- What is a Delegate?
- Why Use Delegates?
- Delegates vs. Function Pointers

2. Declaring and Instantiating Delegates
- Delegate Syntax
- Instantiation

3. Using Delegates
- Assigning Methods to Delegates
- Invoking Delegates

4. Multicast Delegates
- Combining Delegates
- Removing Delegates

5. Built-in Delegates
- Action
- Func
- Predicate

6. Anonymous Methods and Lambda Expressions
- Anonymous Methods
- Lambda Expressions

7. Covariance and Contravariance
- Understanding Covariance
- Understanding Contravariance

8. Generic Delegates
- Using Generic Delegates

9. Delegates and Events
- Event Declaration
- Subscribing and Unsubscribing to Events

10. Best Practices
- Use Strongly-Typed Delegates
- Avoid Delegates for Simple Scenarios
- Utilize Built-in Delegates When Possible

11. Common Mistakes with Delegates
- Not Understanding Delegate Signatures
- Forgetting to Unsubscribe from Events
- Using Delegates Instead of Interfaces

12. Real-World Example
13. Summary

1. Introduction to Delegates

What is a Delegate?

Why Use Delegates?

Delegates vs. Function Pointers

2. Declaring and Instantiating Delegates

Delegate Syntax

public delegate returnType DelegateName(parameterList);

public delegate void Notify(string message);

Instantiation

public class Program
{
    public delegate void Notify(string message);

    public static void Main()
    {
        Notify notifier = DisplayMessage;
        notifier("Hello, Delegates!");
    }

    public static void DisplayMessage(string message)
    {
        Console.WriteLine(message);
    }
}

3. Using Delegates

Assigning Methods to Delegates

public class Messenger
{
    public delegate void MessageHandler(string message);

    public void SendMessage(string msg)
    {
        Console.WriteLine($"Message: {msg}");
    }

    public static void StaticSend(string msg)
    {
        Console.WriteLine($"Static Message: {msg}");
    }
}

public class Program
{
    public static void Main()
    {
        Messenger messenger = new Messenger();
        Messenger.MessageHandler handler1 = messenger.SendMessage; // Instance method
        Messenger.MessageHandler handler2 = Messenger.StaticSend;   // Static method

        handler1("Hello from instance method!");
        handler2("Hello from static method!");
    }
}

Invoking Delegates

public delegate int MathOperation(int a, int b);

public class Calculator
{
    public int Add(int x, int y) => x + y;
    public int Multiply(int x, int y) => x * y;
}

public class Program
{
    public static void Main()
    {
        Calculator calc = new Calculator();
        MathOperation operation;

        // Assign Add method
        operation = calc.Add;
        int sum = operation(5, 3); // Invokes Add
        Console.WriteLine($"Sum: {sum}");

        // Assign Multiply method
        operation = calc.Multiply;
        int product = operation.Invoke(5, 3); // Invokes Multiply
        Console.WriteLine($"Product: {product}");
    }
}

Sample Output:
Sum: 8
Product: 15

4. Multicast Delegates

Combining Delegates

public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        Notify notifier1 = DisplayMessage;
        Notify notifier2 = ShowAlert;
        Notify combinedNotifier = notifier1 + notifier2;

        combinedNotifier("This is a multicast delegate.");
    }

    public static void DisplayMessage(string msg)
    {
        Console.WriteLine($"Display: {msg}");
    }

    public static void ShowAlert(string msg)
    {
        Console.WriteLine($"Alert: {msg}");
    }
}

Removing Delegates

public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        Notify notifier1 = DisplayMessage;
        Notify notifier2 = ShowAlert;
        Notify combinedNotifier = notifier1 + notifier2;

        Console.WriteLine("Invoking combinedNotifier:");
        combinedNotifier("First Invocation");

        // Remove notifier2
        combinedNotifier -= notifier2;

        Console.WriteLine("\nInvoking combinedNotifier after removing ShowAlert:");
        combinedNotifier("Second Invocation");
    }

    public static void DisplayMessage(string msg)
    {
        Console.WriteLine($"Display: {msg}");
    }

    public static void ShowAlert(string msg)
    {
        Console.WriteLine($"Alert: {msg}");
    }
}

Sample Output:
Invoking combinedNotifier:
Display: First Invocation
Alert: First Invocation
Invoking combinedNotifier after removing ShowAlert:
Display: Second Invocation

5. Built-in Delegates

Action

public delegate void Action();
public delegate void Action<T>(T arg);
public delegate void Action<T1, T2>(T1 arg1, T2 arg2);

using System;

public class Program
{
    public static void Main()
    {
        Action greet = SayHello;
        greet();

        Action<string> personalizedGreet = SayHelloTo;
        personalizedGreet("Alice");
    }

    public static void SayHello()
    {
        Console.WriteLine("Hello!");
    }

    public static void SayHelloTo(string name)
    {
        Console.WriteLine($"Hello, {name}!");
    }
}

Sample Output:
Hello!
Hello, Alice!

Func

public delegate TResult Func<TResult>();
public delegate TResult Func<T, TResult>(T arg);
public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);

using System;

public class Program
{
    public static void Main()
    {
        Func<int, int, int> add = Add;
        int result = add(5, 3);
        Console.WriteLine($"Sum: {result}");

        Func<string, string> greet = Greet;
        string greeting = greet("Bob");
        Console.WriteLine(greeting);
    }

    public static int Add(int x, int y)
    {
        return x + y;
    }

    public static string Greet(string name)
    {
        return $"Hello, {name}!";
    }
}

Sample Output:
Sum: 8
Hello, Bob!

Predicate

public delegate bool Predicate<T>(T obj);

using System;
using System.Collections.Generic;

public class Program
{
    public static void Main()
    {
        List<int> numbers = new List<int> { 1, 5, 8, 10, 15, 20 };
        Predicate<int> isEven = IsEven;

        List<int> evenNumbers = numbers.FindAll(isEven);
        Console.WriteLine("Even Numbers:");
        foreach(var num in evenNumbers)
        {
            Console.WriteLine(num);
        }
    }

    public static bool IsEven(int number)
    {
        return number % 2 == 0;
    }
}

Sample Output:
Even Numbers:
8
10
20

6. Anonymous Methods and Lambda Expressions

Anonymous Methods

using System;

public class Program
{
    public delegate void Notify(string message);

    public static void Main()
    {
        Notify notifier = delegate(string msg)
        {
            Console.WriteLine($"Anonymous Method: {msg}");
        };

        notifier("Hello from anonymous method!");
    }
}

Sample Output:
Anonymous Method: Hello from anonymous method!

Lambda Expressions

using System;

public class Program
{
    public delegate int Operation(int x, int y);

    public static void Main()
    {
        // Using lambda expression
        Operation multiply = (a, b) => a * b;
        int product = multiply(4, 5);
        Console.WriteLine($"Product: {product}");

        // Using lambda with statement body
        Operation add = (a, b) =>
        {
            Console.WriteLine($"Adding {a} and {b}");
            return a + b;
        };
        int sum = add(7, 3);
        Console.WriteLine($"Sum: {sum}");
    }
}

Sample Output:
Product: 20
Adding 7 and 3
Sum: 10

7. Covariance and Contravariance

Understanding Covariance

using System;

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks.");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Dog barks.");
    }
}

public delegate Animal AnimalDelegate();

public class Program
{
    public static Animal GetAnimal()
    {
        return new Animal();
    }

    public static Dog GetDog()
    {
        return new Dog();
    }

    public static void Main()
    {
        AnimalDelegate animalDel = GetAnimal;
        animalDel();
        
        // Covariance: Assigning method returning Dog to delegate returning Animal
        animalDel = GetDog;
        animalDel();
    }
}

Sample Output:
Animal speaks.
Dog barks.

Understanding Contravariance

using System;

public class Animal
{
    public virtual void Feed()
    {
        Console.WriteLine("Feeding animal.");
    }
}

public class Dog : Animal
{
    public override void Feed()
    {
        Console.WriteLine("Feeding dog.");
    }
}

public delegate void FeedDelegate(Dog dog);

public class Program
{
    public static void FeedAnimal(Animal animal)
    {
        animal.Feed();
    }

    public static void Main()
    {
        FeedDelegate feedDel = FeedAnimal; // Contravariance: Method takes Animal, delegate expects Dog
        Dog myDog = new Dog();
        feedDel(myDog);
    }
}

Sample Output:
Feeding dog.

8. Generic Delegates

Using Generic Delegates

using System;

public class Program
{
    // Generic delegate
    public delegate T Transformer<T>(T input);

    public static int Square(int x)
    {
        return x * x;
    }

    public static string ToUpperCase(string s)
    {
        return s.ToUpper();
    }

    public static void Main()
    {
        Transformer<int> intTransformer = Square;
        int squared = intTransformer(6);
        Console.WriteLine($"Squared: {squared}");

        Transformer<string> stringTransformer = ToUpperCase;
        string upper = stringTransformer("hello");
        Console.WriteLine($"Uppercase: {upper}");
    }
}

Sample Output:
Squared: 36
Uppercase: HELLO

9. Delegates and Events

Event Declaration

using System;

public class Publisher
{
    // Declare a delegate for the event
    public delegate void NotifyEventHandler(string message);

    // Declare the event using the delegate
    public event NotifyEventHandler OnNotify;

    public void TriggerEvent(string msg)
    {
        // Invoke the event
        OnNotify?.Invoke(msg);
    }
}

public class Subscriber
{
    public void Subscribe(Publisher pub)
    {
        pub.OnNotify += HandleEvent;
    }

    public void HandleEvent(string message)
    {
        Console.WriteLine($"Subscriber received: {message}");
    }
}

public class Program
{
    public static void Main()
    {
        Publisher publisher = new Publisher();
        Subscriber subscriber = new Subscriber();

        subscriber.Subscribe(publisher);

        publisher.TriggerEvent("Event has been triggered!");
    }
}

Sample Output:
Subscriber received: Event has been triggered!

Subscribing and Unsubscribing to Events

using System;

public class Publisher
{
    public delegate void SimpleDelegate();
    public event SimpleDelegate OnSimpleEvent;

    public void RaiseEvent()
    {
        OnSimpleEvent?.Invoke();
    }
}

public class Program
{
    public static void Main()
    {
        Publisher pub = new Publisher();

        // Subscribe methods to the event
        pub.OnSimpleEvent += MethodOne;
        pub.OnSimpleEvent += MethodTwo;

        pub.RaiseEvent();

        // Unsubscribe MethodOne
        pub.OnSimpleEvent -= MethodOne;

        pub.RaiseEvent();
    }

    public static void MethodOne()
    {
        Console.WriteLine("MethodOne invoked.");
    }

    public static void MethodTwo()
    {
        Console.WriteLine("MethodTwo invoked.");
    }
}

Sample Output:
MethodOne invoked.
MethodTwo invoked.
MethodTwo invoked.

10. Best Practices

Use Strongly-Typed Delegates

public delegate void Notify(string message);

Action<string> Notify;

Avoid Delegates for Simple Scenarios

Utilize Built-in Delegates When Possible

using System;

public class Program
{
    public static void Main()
    {
        Action greet = () => Console.WriteLine("Hello!");
        greet();

        Func<int, int, int> add = (a, b) => a + b;
        Console.WriteLine($"Sum: {add(2, 3)}");
    }
}

Sample Output:
Hello!
Sum: 5

Use Events for Event Handling

11. Common Mistakes with Delegates

Not Understanding Delegate Signatures

public delegate void Notify(string message);

public class Program
{
    public static void Main()
    {
        Notify notifier = InvalidMethod; // Error: Signature mismatch
    }

    public static void InvalidMethod(int number)
    {
        Console.WriteLine(number);
    }
}

public static void ValidMethod(string message)
{
    Console.WriteLine(message);
}

public static void Main()
{
    Notify notifier = ValidMethod; // Correct
    notifier("Valid message.");
}

Forgetting to Unsubscribe from Events

public class Subscriber
{
    public void Subscribe(Publisher pub)
    {
        pub.OnNotify += HandleEvent;
    }

    public void HandleEvent(string message)
    {
        Console.WriteLine(message);
    }
}

public class Subscriber
{
    public void Subscribe(Publisher pub)
    {
        pub.OnNotify += HandleEvent;
    }

    public void Unsubscribe(Publisher pub)
    {
        pub.OnNotify -= HandleEvent;
    }

    public void HandleEvent(string message)
    {
        Console.WriteLine(message);
    }
}

Using Delegates Instead of Interfaces

12. Real-World Example

Example: Implementing a Notification System Using Delegates

using System;
using System.Collections.Generic;

public class NotificationCenter
{
    // Delegate for notification handlers
    public delegate void NotificationHandler(string message);

    // Dictionary to hold event subscribers
    private Dictionary<string, NotificationHandler> eventSubscribers = new Dictionary<string, NotificationHandler>();

    // Subscribe to an event
    public void Subscribe(string eventName, NotificationHandler handler)
    {
        if (eventSubscribers.ContainsKey(eventName))
        {
            eventSubscribers[eventName] += handler;
        }
        else
        {
            eventSubscribers[eventName] = handler;
        }
    }

    // Unsubscribe from an event
    public void Unsubscribe(string eventName, NotificationHandler handler)
    {
        if (eventSubscribers.ContainsKey(eventName))
        {
            eventSubscribers[eventName] -= handler;
            if (eventSubscribers[eventName] == null)
            {
                eventSubscribers.Remove(eventName);
            }
        }
    }

    // Notify subscribers of an event
    public void Notify(string eventName, string message)
    {
        if (eventSubscribers.ContainsKey(eventName))
        {
            eventSubscribers[eventName].Invoke(message);
        }
    }
}

public class UserInterface
{
    public void OnUserLoggedIn(string message)
    {
        Console.WriteLine($"UI: {message}");
    }
}

public class Logger
{
    public void Log(string message)
    {
        Console.WriteLine($"Logger: {message}");
    }
}

public class Program
{
    public static void Main()
    {
        NotificationCenter notificationCenter = new NotificationCenter();
        UserInterface ui = new UserInterface();
        Logger logger = new Logger();

        // Subscribers subscribe to the "UserLoggedIn" event
        notificationCenter.Subscribe("UserLoggedIn", ui.OnUserLoggedIn);
        notificationCenter.Subscribe("UserLoggedIn", logger.Log);

        // Trigger the event
        notificationCenter.Notify("UserLoggedIn", "User Alice has logged in.");

        // Unsubscribe Logger from the event
        notificationCenter.Unsubscribe("UserLoggedIn", logger.Log);

        // Trigger the event again
        notificationCenter.Notify("UserLoggedIn", "User Bob has logged in.");
    }
}

Sample Output:
UI: User Alice has logged in.
Logger: User Alice has logged in.
UI: User Bob has logged in.

13. Summary