How should you design and handle events with EventHandler and EventHandler<TEventArgs>? Explain the sender and EventArgs conventions, async event handlers, and how event subscriptions cause memory leaks, including how you would find and fix one.

1. Why the publisher keeps the subscriber alive

GC root (static field / singleton)
  └── Publisher
        └── _orderShipped : EventHandler (MulticastDelegate)
              └── _invocationList[i] → delegate { _target = Subscriber, _methodPtr = Subscriber.Handle }
                                                     └── Subscriber's fields (DbContext, buffers, ...)

The GC considers everything reachable from roots as live. The subscriber can only be collected when the publisher is collected or the delegate is removed.

The reverse isn't a leak: a subscriber holding a reference to the publisher doesn't keep anything extra alive beyond normal ownership.

2. Weak events

A weak event manager stores handlers via WeakReference to the target plus the method, and invokes them only if the target is still alive (cleaning up dead entries). Trade-offs:

• Can't use lambdas that capture local state (the closure object would be collected immediately unless held elsewhere).
• Slight overhead per raise and cleanup.
• Behaviour depends on GC timing — handlers may still run briefly after the subscriber is "done".

.NET's ConditionalWeakTable<TKey, TValue> helps associate data with objects without extending their lifetime.

3. Async event design patterns

public event Func<OrderShippedEventArgs, CancellationToken, Task>? OrderShippedAsync;

private async Task RaiseOrderShippedAsync(OrderShippedEventArgs e, CancellationToken ct)
{
    if (OrderShippedAsync is not { } handlers) return;
    foreach (Func<OrderShippedEventArgs, CancellationToken, Task> h in handlers.GetInvocationList())
    {
        try { await h(e, ct); }
        catch (Exception ex) { _logger.LogError(ex, "Handler failed"); }
    }
}

Sequential awaiting preserves order; Task.WhenAll runs them concurrently. Libraries like AsyncEvent patterns in Discord.Net or Microsoft.VisualStudio.Threading's AsyncEventHandler formalise this.

4. Diagnostic tools

5. Testing for leaks

Automated leak tests create an object, subscribe it, drop references, force GC, and assert it was collected:

var weak = CreateAndSubscribe(publisher);  // returns WeakReference to subscriber
GC.Collect(); GC.WaitForPendingFinalizers(); GC.Collect();
Assert.False(weak.IsAlive);

(Run in Release-like conditions; debug builds may extend lifetimes.)

Try it yourself

1. Subscribe many short-lived objects to a static event and take two dotnet-gcdump snapshots.
2. Find the retention path with gcroot.
3. Fix it with IDisposable unsubscription and verify with a weak-reference test.
4. Implement an async-aware event with Func<T, CancellationToken, Task> and isolated error handling.

namespace Delegates.EventHandlers;

public sealed class FlagsChangedEventArgs(IReadOnlyDictionary<string, bool> flags) : EventArgs
{
    public IReadOnlyDictionary<string, bool> Flags { get; } = flags;
}

public sealed class FeatureFlagService   // registered as a singleton
{
    private Dictionary<string, bool> _flags = new() { ["NewPricing"] = false };

    public event EventHandler<FlagsChangedEventArgs>? FlagsChanged;

    public bool IsEnabled(string name) => _flags.GetValueOrDefault(name);

    public void Update(string name, bool enabled)
    {
        _flags = new Dictionary<string, bool>(_flags) { [name] = enabled };
        OnFlagsChanged(new FlagsChangedEventArgs(_flags));
    }

    private void OnFlagsChanged(FlagsChangedEventArgs e) => FlagsChanged?.Invoke(this, e);
}

// Leaky version: scoped subscriber, never unsubscribes
public sealed class LeakyPricingCalculator
{
    private readonly byte[] _cache = new byte[1024 * 1024];
    public LeakyPricingCalculator(FeatureFlagService flags) => flags.FlagsChanged += OnFlagsChanged;
    private void OnFlagsChanged(object? sender, FlagsChangedEventArgs e) => Array.Clear(_cache);
}

// Fixed version: unsubscribes when the DI scope disposes it
public sealed class PricingCalculator : IDisposable
{
    private readonly FeatureFlagService _flags;
    private bool _useNewPricing;

    public PricingCalculator(FeatureFlagService flags)
    {
        _flags = flags;
        _useNewPricing = flags.IsEnabled("NewPricing");
        _flags.FlagsChanged += OnFlagsChanged;
    }

    private void OnFlagsChanged(object? sender, FlagsChangedEventArgs e)
        => _useNewPricing = e.Flags.GetValueOrDefault("NewPricing");

    public decimal Price(decimal baseAmount) => _useNewPricing ? baseAmount * 0.95m : baseAmount;

    public void Dispose() => _flags.FlagsChanged -= OnFlagsChanged;
}

public static class Program
{
    public static void Main()
    {
        var flags = new FeatureFlagService();

        for (var i = 0; i < 100; i++) _ = new LeakyPricingCalculator(flags);   // 100 MB kept alive
        for (var i = 0; i < 100; i++) { using var calc = new PricingCalculator(flags); _ = calc.Price(100m); }

        GC.Collect();
        GC.WaitForPendingFinalizers();
        Console.WriteLine($"Heap after collect: {GC.GetTotalMemory(forceFullCollection: true) / 1024 / 1024} MB");

        flags.FlagsChanged += async (_, e) =>
        {
            try { await Task.Delay(10); Console.WriteLine("async handler done"); }
            catch (Exception ex) { Console.WriteLine(ex); } // async void: catch inside
        };
        flags.Update("NewPricing", true);
        Thread.Sleep(50);
    }
}