Delegates & Events

A delegate is a type-safe reference to a method — a typed function pointer. You declare it as a type with a fixed signature, assign any method whose parameters and return type match, then call the delegate variable like a method to invoke the referenced target. The compiler checks signatures, so a mismatched method is rejected.

A lambda like x => x * 2 is an inline anonymous function: a compact => syntax for a method body assignable to a matching delegate or an expression tree. Its body can read and mutate variables from the enclosing scope, not just its own parameters. When it captures such an outer variable it becomes a closure, and the captured variable lives on as long as the lambda does.

They are generic delegate types from the standard library, so you rarely declare your own. Func<...,TResult> takes zero or more inputs and returns a value of TResult. Action<...> takes inputs but returns void. Predicate<T> takes one T and returns bool, used for tests like filtering. Preferring them keeps signatures consistent and avoids boilerplate delegate declarations.

An anonymous method uses the older delegate { ... } syntax to supply an inline delegate body without naming a method; a lambda is the newer, terser form of the same idea. Both compile to a hidden method and can be assigned wherever a delegate is expected. Both also form closures — they capture outer variables by reference, sharing the live variable rather than a copy, so changes are seen on both sides.

Binding is how a method call is matched to an implementation. Early or static binding resolves the call at compile time from the variable's declared type, giving type checking, IntelliSense, and fast direct calls. Late binding defers resolution to runtime against the actual object — via dynamic or reflection — so the member need not be known when compiling. You trade compile-time safety and speed for flexibility.

Every delegate holds an invocation list of targets. += appends a method and -= removes one, so a single delegate can reference many methods. Invoking it runs every target in the order they were added. For a value-returning delegate you only get the last target's result; the earlier returns are discarded. If any target throws, invocation stops and the remaining methods never run.

Dynamic dispatch selects which method implementation runs based on the object's actual runtime type, not the declared type of the reference. For virtual methods the runtime looks the target up through the object's method table, so an overriding subclass version is chosen even via a base-type reference. Static dispatch instead fixes the target at compile time from the declared type, so non-virtual calls cannot be overridden polymorphically.