What are delegates and events?

Question

Accepted Answer

A **delegate** is a type-safe reference to a method (like a function pointer) — it lets you treat methods as data: store them, pass them as arguments, and invoke them. **Events** are a pattern built on delegates for the publish-subscribe (observer) model. They underpin callbacks, LINQ, and event-driven programming in C#. ## Delegates — methods as values ```csharp // a delegate type defines a method signature public delegate int Operation(int a, int b); Operation add = (a, b) => a + b; // assign a method/lambda to it Operation multiply = (a, b) => a * b; int result = add(2, 3); // invoke → 5 // pass a delegate as an argument (higher-order function) int Apply(Operation op, int x, int y) => op(x, y); Apply(multiply, 4, 5); // 20 ``` A delegate holds a reference to a method matching its signature, enabling methods to be passed around and invoked dynamically. ## Built-in delegate types (use these, not custom ones) ```csharp Func add = (a, b) => a + b; // Func — takes args, RETURNS a value Action log = msg => Console.WriteLine(msg); // Action — returns VOID Predicate isPositive = n => n > 0; // Predicate — returns bool // used heavily in LINQ and APIs: list.Where(x => x > 0).Select(x => x * 2); // lambdas are delegates ``` In modern C#, you usually use the built-in **`Func<>`** (returns a value), **`Action<>`** (returns void), and `Predicate<>` rather than declaring custom delegate types. Lambdas (`x => ...`) create delegates — the basis of LINQ. ## Events — the publish-subscribe pattern ```csharp public class Button { public event EventHandler Clicked; // an EVENT (based on a delegate) public void Click() => Clicked?.Invoke(this, EventArgs.Empty); // raise it } var button = new Button(); button.Clicked += (sender, e) => Console.WriteLine("clicked!"); // SUBSCRIBE (+=) button.Clicked -= handler; // unsubscribe (-=) ``` An **event** wraps a delegate to provide safe pub-sub: subscribers register handlers with `+=`, the publisher raises the event (`Invoke`), and all handlers run. Events restrict outside code to only subscribing/unsubscribing (not raising or clearing) — encapsulation for the observer pattern. ## Why it matters Delegates and events are important C# features that enable treating methods as data, callbacks, and event-driven programming — and understanding them is valuable both for using them and for grasping how much of C# and .NET works. **Delegates** (type-safe method references) are the foundation: they let methods be stored, passed, and invoked dynamically, which underpins **LINQ** (lambdas passed to `Where`/`Select` are delegates), callbacks, and functional-style programming. Knowing to use the built-in **`Func<>`/`Action<>`/`Predicate<>`** delegate types (rather than declaring custom ones) is practical, everyday knowledge since they appear throughout the framework and are how you pass behavior to LINQ and many APIs. **Events** build on delegates to implement the publish-subscribe (observer) pattern safely — they're how C# handles event-driven scenarios (UI events, notifications, decoupled communication), with `+=`/`-=` for subscribing/unsubscribing. Understanding delegates (especially Func/Action and lambdas, the basis of LINQ), and events (the pub-sub pattern for decoupled, event-driven code) is important for working effectively with C#, since these features underpin LINQ, callbacks, and event handling that appear constantly. Mastering them — particularly recognizing that lambdas are delegates and how they enable LINQ and functional patterns — is frequently-applied knowledge that reflects understanding of C#'s functional capabilities and event-driven model, and is a common interview topic.