What is a multicast delegate? Explain how += and -= build the invocation list, the order handlers run in, what happens to return values and exceptions, why delegates are thread-safe to read but events need care, and how GetInvocationList helps.

1. Internal representation

MulticastDelegate
  _target / _methodPtr        (for single-cast)
  _invocationList: object[]   (for multicast: array of single-cast delegates)
  _invocationCount: nint      (number of entries used)

Delegate.Combine creates a new delegate whose invocation list is the concatenation (it may over-allocate the array to make repeated += cheaper). Delegate.Remove searches from the end for a matching sub-list and creates a new delegate without it; if nothing remains, returns null.

2. Combine requires exact runtime types

Delegate.Combine(a, b) throws ArgumentException if a.GetType() != b.GetType(). With variance (Action<object> assigned to Action<string>), runtime types can differ from static types — a known gotcha.

3. Field-like event accessors

public event EventHandler? Changed;
// compiler generates roughly:
private EventHandler? _changed;
public void add_Changed(EventHandler value)
{
    EventHandler? current = _changed, prior;
    do
    {
        prior = current;
        var combined = (EventHandler?)Delegate.Combine(prior, value);
        current = Interlocked.CompareExchange(ref _changed, combined, prior);
    } while (current != prior);
}

This lock-free loop retries if another thread changed the field concurrently. Before C# 4, field-like events used lock(this), which was problematic.

4. Async handlers

event Func<T, Task> handlers invoked directly only return the last task — earlier handlers' tasks are ignored (exceptions lost, completion not awaited). Proper async events iterate the invocation list:

var tasks = handler.GetInvocationList().Cast<Func<OrderPaid, Task>>().Select(h => h(e));
await Task.WhenAll(tasks);

Or sequentially with foreach + await to preserve order.

5. Performance

• Invoking a multicast delegate with N handlers is N indirect calls.
• Each +=/-= allocates a new delegate and array (O(N) copy) — fine for typical subscription patterns, not for high-frequency subscribe/unsubscribe.
• For many subscribers or dynamic subscriptions, consider List<Action<T>> with explicit locking or an observer/mediator library.

Try it yourself

1. Combine three Func<int> delegates returning 1, 2, 3 and print the result.
2. Make the second handler of an Action throw and observe that the third doesn't run.
3. Use GetInvocationList() to collect all results and isolate exceptions.
4. Write Func<Task> handlers and compare invoking directly vs iterating and Task.WhenAll.

namespace Delegates.Multicast;

public sealed record Document(string Title);

public sealed class PluginHost
{
    private Func<Document, bool>? _beforeSave;

    public void Register(Func<Document, bool> veto) => _beforeSave += veto;
    public void Unregister(Func<Document, bool> veto) => _beforeSave -= veto;

    // Bug: only the last plug-in's answer counts
    public bool CanSaveNaive(Document doc) => _beforeSave?.Invoke(doc) ?? true;

    // Fix: ask every plug-in, isolate failures, stop on the first veto
    public bool CanSave(Document doc)
    {
        var handlers = _beforeSave;
        if (handlers is null) return true;

        foreach (var d in handlers.GetInvocationList())
        {
            var plugin = (Func<Document, bool>)d;
            try
            {
                if (!plugin(doc))
                {
                    Console.WriteLine($"Vetoed by {plugin.Method.Name}");
                    return false;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Plug-in {plugin.Method.Name} failed: {ex.Message}");
            }
        }
        return true;
    }
}

public static class Program
{
    private static bool RequireTitle(Document d) => !string.IsNullOrWhiteSpace(d.Title);
    private static bool Broken(Document d) => throw new InvalidOperationException("plug-in bug");
    private static bool AlwaysOk(Document d) => true;

    public static void Main()
    {
        var host = new PluginHost();
        host.Register(RequireTitle);
        host.Register(Broken);
        host.Register(AlwaysOk);

        var doc = new Document("");
        try { Console.WriteLine(host.CanSaveNaive(doc)); }
        catch (InvalidOperationException) { Console.WriteLine("Naive: exception stopped the chain"); }

        Console.WriteLine(host.CanSave(doc)); // Vetoed by RequireTitle, False

        host.Unregister(Broken);              // works: same method group, same (null) target
        Func<Document, bool> lambda = d => true;
        host.Register(lambda);
        host.Unregister(lambda);              // works only because we kept the instance
    }
}