Events

An event is a multicast delegate field with a guard around it.

public class Button
{
    public event EventHandler? Clicked;           // the event
    public void Click() => Clicked?.Invoke(this, EventArgs.Empty);
}

Outside the declaring class, code may only += (subscribe) and -= (unsubscribe). It cannot invoke the event, assign it with =, or read its invocation list. Those restrictions are the whole point: with a plain public delegate field, any subscriber could fire the event or wipe out everyone else's handlers with a single =.

The .NET convention is EventHandler or EventHandler<TEventArgs>: the handler receives the sender and an object carrying the details. Clicked?.Invoke(...) matters because an event with no subscribers is null; calling it directly would throw NullReferenceException.

Unsubscribing

-= removes a delegate equal to the one given. Two delegates are equal when they point to the same method on the same target. Writing the same lambda text twice produces two different delegates:

1public class Button2{3    public event EventHandler? Clicked;4    public int HandlerCount => Clicked?.GetInvocationList().Length ?? 0;5    public void Click() => Clicked?.Invoke(this, EventArgs.Empty);6}7 8public static class Solution9{10    static readonly List<string> Log = new();11    static void OnClick(object? sender, EventArgs e) => Log.Add("method");12 13    public static string Describe()14    {15        Log.Clear();16        var b = new Button();17        b.Clicked += (s, e) => Log.Add("lambda");18        b.Clicked += OnClick;19        int before = b.HandlerCount;20 21        b.Clicked -= (s, e) => Log.Add("lambda");   // a different delegate instance: removes nothing22        int afterLambda = b.HandlerCount;23 24        b.Clicked -= OnClick;                       // equal delegate (same method, same target): removed25        int afterMethod = b.HandlerCount;26 27        b.Click();28        return $"before={before} after -= lambda={afterLambda} after -= method={afterMethod} ran={string.Join(",", Log)}";29    }30}

The lambda handler survived -= (the count stayed at 2 and it still ran), while the method-group handler was removed. To unsubscribe a lambda, keep it in a variable and use that variable for both += and -=.

When a handler throws

Raising an event calls the handlers one after another on the raising thread. An exception from one handler propagates out of Invoke, and the handlers after it never run:

1public class Sensor2{3    public event Action<int>? Reading;4    public void Publish(int value) => Reading?.Invoke(value);5}6 7public static class Solution8{9    public static string Describe()10    {11        var log = new List<string>();12        var s = new Sensor();13        s.Publish(1);                        // no subscribers: ?.Invoke does nothing14 15        s.Reading += v => log.Add("first:" + v);16        s.Reading += v => throw new InvalidOperationException("broken handler");17        s.Reading += v => log.Add("third:" + v);18 19        try { s.Publish(2); }20        catch (InvalidOperationException e) { log.Add("caught:" + e.Message); }21 22        return string.Join(", ", log);23    }24}

The first Publish(1), with no subscribers, did nothing thanks to ?.. For Publish(2), the first handler ran, the second threw, and the third was skipped. If every handler must run, walk GetInvocationList() and wrap each call in its own try/catch.

Common mistakes

• Raising without a null check. Clicked(this, e) throws NullReferenceException when nobody subscribed. Use ?.Invoke.
• Unsubscribing with a fresh lambda. Shown above: nothing is removed. Store the delegate.
• Forgetting to unsubscribe from a long-lived publisher. The publisher's invocation list holds a reference to each subscriber, so a short-lived object subscribed to a static or singleton event is never garbage-collected.
• Assuming a throwing handler only affects itself. It stops the remaining handlers and surfaces in the code that raised the event.

What interviewers ask

• "What is the difference between an event and a public delegate field?" Outside the class an event allows only += and -=; a field can also be invoked or overwritten by anyone.
• "How can events cause memory leaks?" The publisher references every subscriber through its handlers; if the publisher outlives them and they never unsubscribe, they stay reachable.