Delegates, Events & Lambdas

var actions = new List<Action>();
for (int i = 0; i < 3; i++) {
  int captured = i; // must copy into a NEW local to capture correctly in a 'for' loop
  actions.Add(() => Console.WriteLine(captured));
}
foreach (var action in actions) action(); // 0, 1, 2 (correct, thanks to the local copy)

Common follow-ups: Does this same capture pitfall still apply to C#'s modern 'foreach' loops, or only to 'for' loops?

Func<int, int, int> add = (a, b) => a + b;
Action<string> log = message => Console.WriteLine(message);
Predicate<int> isEven = n => n % 2 == 0;

List<int> numbers = new() { 1, 2, 3, 4 };
int firstEven = numbers.Find(isEven); // 2

Common follow-ups: Why does Predicate<T> still exist as a separate type when Func<T, bool> could express the same shape?

public class WeakEventSubscription {
  private readonly WeakReference<Action> _weakHandler;
  public WeakEventSubscription(Action handler) { _weakHandler = new WeakReference<Action>(handler); }
  public void Raise() {
    if (_weakHandler.TryGetTarget(out var handler)) handler();
    // if the target was collected, TryGetTarget returns false -- no leak, no crash
  }
}

Common follow-ups: Why do WPF and similar frameworks provide built-in weak event manager helpers rather than expecting every developer to implement this manually?

// No capture: compiled as a cached static delegate, zero per-call allocation
Func<int, int> square = x => x * x;

// Captures 'multiplier': compiler generates a closure class instance per call
int multiplier = 3;
Func<int, int> multiply = x => x * multiplier;

Common follow-ups: How would you restructure code to avoid this closure allocation in a genuinely performance-critical hot path?

public delegate object Factory(); // expects something returning 'object'
string CreateString() => "hello"; // returns a MORE derived type (string)
Factory factory = CreateString; // OK: covariant return type match

public delegate void Handler(string s);
void HandleObject(object o) => Console.WriteLine(o); // accepts a LESS derived type
Handler handler = HandleObject; // OK: contravariant parameter type match

Common follow-ups: How does this delegate variance relate to the similar covariance/contravariance rules for generic interfaces like IEnumerable<out T>?

button.Clicked += async (sender, e) => {
  try {
    await SaveDataAsync(); // legitimate async void usage: matches EventHandler's signature
  } catch (Exception ex) {
    Console.WriteLine($"Error in click handler: {ex.Message}"); // must catch here -- caller can't
  }
};

Common follow-ups: Why can't a caller catch an exception thrown from inside an 'async void' method the normal way, unlike an 'async Task' method?

delegate void MessageDelegate(string message);

void PrintMessage(string msg) => Console.WriteLine(msg);

MessageDelegate del = PrintMessage;
del("Hello, delegates!"); // invokes PrintMessage indirectly

// Multicast: both methods run in sequence
del += msg => Console.WriteLine("Also: " + msg);
del("Hi again");

Common follow-ups: How do events build on top of delegates to add publish/subscribe semantics?;What's the difference between Func<T,R> and a custom delegate with the identical signature?