Delegates, lambdas and closures

A delegate is a type-safe reference to a method: an object you can store, pass around and invoke. You rarely declare your own delegate types any more; the generic ones cover almost everything:

• Func<T1, ..., TResult>: takes arguments, returns a value.
• Action<T1, ...>: takes arguments, returns nothing.
• Predicate<T>: an older delegate type with the same shape as Func<T, bool>, used by List.FindAll and friends. The two are distinct types, so one cannot be assigned to the other.

A delegate can point at a named method (a method group) or at a lambda, an inline anonymous function:

1public static class Solution2{3    static int Twice(int x) => x * 2;4 5    public static string Describe()6    {7        Func<int, int> f = Twice;                 // method group8        Func<int, int> g = x => x + 1;            // lambda9        Predicate<string> empty = string.IsNullOrEmpty;10 11        var lines = new List<string>();12        Action<string> log = null;13        log += s => lines.Add("A:" + s);14        log += s => lines.Add("B:" + s);15        log("hi");16 17        Func<int, int> composed = x => g(f(x));18        return $"f(5)={f(5)} g(5)={g(5)} composed(5)={composed(5)} empty(\"\")={empty("")} | {string.Join(",", lines)}";19    }20}

log += ... shows that delegates are multicast: += builds an invocation list, and invoking the delegate calls every entry in order. Events, in the next lesson, are built on exactly this.

Closures capture variables

A lambda may use local variables of the method that created it. The compiler moves such a variable into a hidden object shared by the method and the lambda, so the variable lives as long as the lambda does, even after the method has returned. That is a closure.

1public static class Solution2{3    static Func<int> MakeCounter()4    {5        int count = 0;               // captured: lives on after MakeCounter returns6        return () => ++count;7    }8 9    public static string Describe()10    {11        var a = MakeCounter();12        var b = MakeCounter();13        a(); a();14        int fromA = a();15        int fromB = b();16 17        var forActions = new List<Func<int>>();18        for (int i = 0; i < 3; i++) forActions.Add(() => i);19 20        var foreachActions = new List<Func<int>>();21        foreach (var n in new[] { 0, 1, 2 }) foreachActions.Add(() => n);22 23        return $"a={fromA} b={fromB} | for: {string.Join(",", forActions.Select(f => f()))} | " +24               $"foreach: {string.Join(",", foreachActions.Select(f => f()))}";25    }26}

Each call to MakeCounter creates a new count, so a and b count independently: a reached 3 while b is at 1. This is how you give a function private state without writing a class.

The second half shows the classic trap. A for loop declares one variable i for the whole loop. All three lambdas captured that same variable, and by the time they run the loop has left it at 3. A foreach loop is different: since C# 5 it declares a fresh iteration variable each time round, so each lambda sees its own value.

Common mistakes

• Capturing a for loop variable. Shown above: every lambda sees the final value. Copy it first (int copy = i;) and capture the copy.
• Expecting a captured value to be frozen. A closure reads the variable when it runs, so a later assignment to that variable changes what the lambda returns.
• Creating the shared state inside the lambda. State that must survive between calls (a cache, a counter) has to be declared outside the lambda and captured; declared inside, it is created fresh on every call. The exercise below is about exactly this.

What interviewers ask

• "What is the difference between Func and ?" returns a value (its last type argument), returns .