What is an event in C#, and how is it different from a public delegate field? Explain what the event keyword generates, field-like events versus custom add/remove accessors, how to raise an event safely, and static events.

How I would answer this in an interview

An event is a delegate-backed member that exposes only subscribe and unsubscribe to outside code, while keeping raising and replacing private to the declaring type. A public delegate field gives everyone full control — including wiping out all subscribers or raising the event themselves. I'd cover what event generates, field-like vs custom accessors, raising safely, and static events.

1. Event vs public delegate field

public sealed class OrderService
{
    public Action<Order>? OrderPlacedField;               // public delegate field
    public event EventHandler<OrderPlacedEventArgs>? OrderPlaced;  // event
}

// From outside:
service.OrderPlacedField = null;                 // allowed - removes everyone!
service.OrderPlacedField?.Invoke(fakeOrder);      // allowed - anyone can raise it
service.OrderPlaced += Handle;                    // allowed
service.OrderPlaced -= Handle;                    // allowed
// service.OrderPlaced = null;                    // CS0070 - not allowed
// service.OrderPlaced?.Invoke(...);              // CS0070 - not allowed outside the type

Events encode the observer pattern: the publisher owns notification; subscribers can only register interest.

2. What the event keyword generates

A field-like event public event EventHandler? Changed; generates:

• a private delegate field,
• a public add_Changed accessor using a lock-free Interlocked.CompareExchange loop with Delegate.Combine,
• a public remove_Changed accessor with Delegate.Remove,
• event metadata linking them.

Inside the class, Changed refers to the field, so you can invoke it; outside, it refers to the event, so only +=/-= work.

3. Custom add/remove accessors

private readonly EventHandlerList _handlers = new();
private static readonly object s_changedKey = new();

public event EventHandler Changed
{
    add    { lock (_handlers) _handlers.AddHandler(s_changedKey, value); }
    remove { lock (_handlers) _handlers.RemoveHandler(s_changedKey, value); }
}

Use custom accessors to:

• forward subscriptions to another object (wrappers/adapters: add => _inner.Changed += value;),
• store handlers in a sparse structure when a type has many events but few are used (WinForms controls use EventHandlerList to avoid a field per event),
• implement weak events (store weak references to handlers' targets),
• add logging/validation or lazily start an underlying subscription (e.g. start listening to a socket when the first handler subscribes).

With custom accessors, there's no backing field — you raise the event from your own storage.

4. Raising an event safely

protected virtual void OnOrderPlaced(OrderPlacedEventArgs e) => OrderPlaced?.Invoke(this, e);

• ?.Invoke reads the delegate once, so there's no race between the null check and the call if another thread unsubscribes the last handler.
• The protected virtual OnXxx pattern lets derived classes override raising behaviour.
• Exceptions from handlers propagate to the raiser and stop later handlers — decide whether to isolate them (GetInvocationList with try/catch).
• Raise events outside locks to avoid deadlocks when handlers call back into your object.
• Handlers run synchronously on the raising thread; long-running handlers block the publisher.

5. Static events

public static class AppEvents
{
    public static event EventHandler<TenantChangedEventArgs>? TenantChanged;
}

Static events live for the process lifetime and hold strong references to every subscriber's target. Any instance that subscribes and never unsubscribes is kept alive forever — the classic memory leak (e.g. per-request objects or view models subscribing to SystemEvents or a static hub). In server apps, static events also mix tenants and requests. Prefer DI-scoped publishers, IObservable<T>, channels or a mediator; if static events are unavoidable, unsubscribe in Dispose or use weak events.

6. A production example

A desktop-to-web migration kept a static ConfigChanged event that per-request services subscribed to in their constructors. In the web app, every request created services that subscribed and never unsubscribed; memory grew steadily and dotnet-gcdump showed hundreds of thousands of service instances rooted by the static event's invocation list. We replaced it with IOptionsMonitor<T>.OnChange registrations in singletons only (disposing the returned IDisposable), and the leak disappeared.