A Complete Guide - Delegates and Multicast Delegates in C#

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