Delegates And Multicast Delegates In C# Complete Guide

1. What are delegates in C#?

Answer: Delegates in C# are similar to function pointers in other languages. They hold references to methods and can be passed as parameters. Here, Func and Action are predefined generic delegates:

public delegate void Print(string message);
public class Program {
    public static void Main() {
        Print printDelegate = Console.WriteLine;
        printDelegate("Hello!");
    }
}

2. How do you declare and invoke a delegate in C#?

Answer: Declaring a delegate involves specifying the return type and parameter list of the methods it will reference. Invoking it is simply calling the delegate like a method.

public delegate int AddNumbers(int x, int y);

public class Program {
    static int Sum(int a, int b) {
        return a + b;
    }

    public static void Main() {
        AddNumbers myDelegate = new AddNumbers(Sum); // Declaration
        int result = myDelegate(5, 3);              // Invocation
        Console.WriteLine(result);                    // Output: 8
    }
}

3. Can you explain predefined delegates in C#?

Answer: Yes, C# includes predefined delegates such as Action, Func, Predicate, EventHandler, and PropertyChangedEventHandler. Action<T> accepts parameters but doesn't return anything, whereas Func<T, TResult> takes parameters and returns a value. For example, using Action and Func:

using System;

class Program {
    public static void Main() {
        Action<string> greetDelegate = (name) => Console.WriteLine($"Hello {name}!");
        greetDelegate("Alice");

        Func<int, int, int> addDelegate = (a, b) => a + b;
        int sum = addDelegate(4, 6);
        Console.WriteLine(sum);
    }
}

4. What are multicast delegates in C#?

Answer: Multicast delegates allow multiple methods to be invoked when the delegate is called. A multicast delegate combines multiple instances of single-cast delegates into one delegate instance using the + operator.

public delegate void Notify(string message);

public class NotificationSystem {
    public Notify NotifyEvent;

    public void TriggerNotification() {
        NotifyEvent?.Invoke("Notifications Triggered!");
    }
}

public class Program {
    public static void HandleNotification1(string message) {
        Console.WriteLine("Handler 1 received: " + message);
    }

    public static void HandleNotification2(string message) {
        Console.WriteLine("Handler 2 received: " + message);
    }

    public static void Main() {
        var system = new NotificationSystem();
        system.NotifyEvent += HandleNotification1;
        system.NotifyEvent += HandleNotification2;
        system.TriggerNotification();
    }
}

5. How do you remove methods from multicast delegates?

Answer: Methods can be removed from multicast delegates using the -= operator. Only the specified method will be unsubscribed, not all.

public static void Main() {
    var system = new NotificationSystem();
    system.NotifyEvent += HandleNotification1;
    system.NotifyEvent += HandleNotification2;
    system.NotifyEvent -= HandleNotification1; // HandleNotification1 is unsubscribed
    system.TriggerNotification();               // Handler 2 only receives notification
}

6. Can delegates be used with anonymous methods?

Answer: Yes, delegates can reference anonymous methods – blocks of code that do not have a name and can be defined directly where they are used.

public static void Main() {
    Notify anonMethod = delegate(string msg) {
        Console.WriteLine("Anonymous method received message: " + msg);
    };

    anonMethod("Hello via Anonymous Method!");
}

7. How do you use lambdas with delegates?

Answer: Lambda expressions provide a more concise syntax for inline anonymous methods. They are often used with predefined generic delegates like Func<T, TResult> and Action.

public static void Main() {
    Notify lambdaMethod = (msg) => Console.WriteLine(msg);
    lambdaMethod("Greetings from Lambda!");

    Func<int, int> square = x => x * x;
    Console.WriteLine(square(3)); // Output: 9
}

8. Can delegates be used for asynchronous programming in C#?

Answer: Yes, delegates can be used for executing methods asynchronously through methods like BeginInvoke() and EndInvoke(). However, these are less common in modern asynchronous programming, which typically uses async/await.

9. How do delegates differ from interfaces in C#?

Answer: Delegates refer to methods by their signature, while interfaces define contracts for classes or structs. Delegates can encapsulate only a reference to a single method or a list of methods via multicast delegates, whereas interfaces can contain multiple methods, properties, events.

public interface IGreeting {
    void Greet(string name);
}

// Implementing an interface
public class FormalGreeting : IGreeting {
    public void Greet(string name) {
        Console.WriteLine("Good day, " + name);
    }
}

public class Program {
    public static void Main() {
        Notify del = new Notify(FormalGreeting.Greet);
        del("Bob");
    }
}

10. What are common use cases for delegates and multicast delegates in C#?

Answer: Delegates are commonly used for:

• Event handling
• Asynchronous method calls
• Callback mechanisms
• Defining method invocation parameters

Multicast delegates are particularly useful in scenarios where you need to notify multiple subscribers of an event, such as:

• Publishing/Subscriber patterns
• Logging frameworks where a logging event might be handled by multiple loggers