C# Delegates, Lambdas and Events

Func<int, int> square = x => x * x;
Console.WriteLine(square(5));                 // 25

Func<decimal, decimal, decimal> add = (a, b) => a + b;
Action<string> log = message => Console.WriteLine($"[log] {message}");
Predicate<int> isEven = n => n % 2 == 0;

log("Started");

• Func<T1, ..., TResult> takes inputs and returns a value; the last type parameter is the return type.
• Action<T1, ...> takes inputs and returns nothing.
• Predicate<T> takes one input and returns a bool.
• A lambda's parameters go on the left of => and the body on the right. A body in braces can contain several statements and a return.
• An existing method can be used too: Func<string, int> parse = int.Parse;.

Methods that accept delegates can be customised by their callers:

static List<T> Filter<T>(List<T> items, Func<T, bool> keep)
{
    var result = new List<T>();
    foreach (var item in items)
        if (keep(item)) result.Add(item);
    return result;
}

var adults = Filter(people, p => p.Age >= 18);

That's exactly how LINQ's Where works. Methods can also return functions, such as Func<decimal, decimal> MakeDiscount(decimal percent), which builds a new function from a setting.

A lambda can use variables from the code around it. It captures the variable itself, not a copy of its value at the time:

int count = 0;
Action increment = () => count++;
increment();
increment();
Console.WriteLine(count);    // 2

Captured variables live as long as the lambda does. This is powerful for counters and callbacks, but be careful: a lambda that captures a variable later sees its current value, which can surprise you inside loops.

An event lets a class announce that something happened, and lets any number of other objects react:

class Downloader
{
    public event EventHandler<int>? ProgressChanged;

    public void Run()
    {
        for (int p = 50; p <= 100; p += 50)
            ProgressChanged?.Invoke(this, p);
    }
}

var d = new Downloader();
d.ProgressChanged += (sender, percent) => Console.WriteLine($"{percent}%");
d.Run();

• += subscribes a handler and -= unsubscribes it.
• ?.Invoke raises the event only if someone has subscribed.
• Only the class that declares an event can raise it; outside code can only subscribe and unsubscribe.

Closures capture variables, not values, and this matters most inside loops. A for loop has one variable i that's shared by every repetition, so lambdas created in the loop all see its final value:

var actions = new List<Action>();
for (int i = 0; i < 3; i++)
    actions.Add(() => Console.Write(i + " "));
foreach (var a in actions) a();   // 3 3 3

A foreach loop is different: since C# 5, it creates a fresh variable for each item, so the same code with foreach (int n in new[] { 0, 1, 2 }) prints 0 1 2.

To fix a for loop, copy the value into a variable declared inside the loop body. Each repetition gets its own copy:

for (int i = 0; i < 3; i++)
{
    int copy = i;
    actions.Add(() => Console.Write(copy + " "));   // 0 1 2
}

You'll hit this when creating buttons, timers or tasks in a loop. If a lambda shouldn't capture anything at all, mark it static, as in static x => x * 2; the compiler then reports an error if it accidentally uses a variable from outside.