Lambda Expressions

A lambda is a method written where it is used, with no name and no declaration. order => order.Total > 50_000m is a complete function: it takes an order and returns a bool.

The previous lesson passed named methods around as values. Most of the time those methods are two lines long, used once, and naming them adds a trip to another part of the file for whoever is reading. A lambda puts the behaviour at the point of use.

It also has one property that surprises people, and the second half of this lesson is about that: a lambda can use variables from the code around it, and it keeps using the variable rather than the value it held at the time.

Order order = new Order("SO-4471") { Total = 62_000m };

// parameter => single expression. The return is implied.
Func<decimal, decimal> addTax = amount => amount * 1.18m;
Func<Order, bool> isLarge = o => o.Total >= 50_000m;
Action<string> log = message => Console.WriteLine($"[orders] {message}");

// No parameters: an empty pair of brackets.
Action greet = () => Console.WriteLine("Order service ready");

// Two parameters: brackets and commas.
Func<decimal, decimal, decimal> applyDiscount = (total, rate) => total * (1m - rate);

// Several statements: braces, and an explicit return.
Func<Order, string> describe = o =>
{
    string size = o.Total >= 50_000m ? "large" : "standard";
    return $"{o.Reference} is a {size} order";
};

Console.WriteLine(addTax(1_000m));            // 1180
Console.WriteLine(isLarge(order));            // True
Console.WriteLine(describe(order));           // SO-4471 is a large order
log("totals recalculated");
greet();

• The => separates the parameters from the body. Nothing about a lambda is magic: each of these is a method the compiler generates for you.
• Parameter types are usually left out because the delegate type supplies them. addTax is a Func<decimal, decimal>, so amount must be a decimal. You can write them explicitly — (decimal amount) => ... — when it helps a reader.
• In Func<A, B, C>, the last type argument is the return type and the others are parameters. Action has no return type at all.
• A single-expression lambda returns that expression's value automatically. Once you add braces you are writing statements, so a return is required.
• The body can be as long as you like, and the next callouts argue for keeping it short.

List<Action> jobs = new List<Action>();

for (int i = 0; i < 3; i++)
{
    jobs.Add(() => Console.WriteLine($"Processing batch {i}"));
}

foreach (Action job in jobs)
{
    job();
}
// Processing batch 3
// Processing batch 3
// Processing batch 3

// The fix: a fresh variable inside the loop, so each lambda captures its own.
List<Action> fixedJobs = new List<Action>();

for (int i = 0; i < 3; i++)
{
    int batch = i;
    fixedJobs.Add(() => Console.WriteLine($"Processing batch {batch}"));
}

foreach (Action job in fixedJobs)
{
    job();
}
// Processing batch 0
// Processing batch 1
// Processing batch 2

• In a for loop, i is one variable that lives for the whole loop. All three lambdas captured that one variable.
• None of them ran during the loop — they were only stored. By the time the first one ran, the loop had finished and i held 3, which is the value that ended the loop.
• int batch = i; declares a new variable on each pass, so there are three of them and each lambda captures a different one. That is the whole fix, and it is why the line looks pointless until you know this.
• A detail worth knowing: foreach behaves differently. Its iteration variable has been a fresh variable per iteration since C# 5, so the same code written with foreach gives the expected output. The surprise survives in for loops, and anywhere a captured variable is changed after the lambda was created.
• The general rule this teaches: if you want a snapshot, take a copy into a local variable. Capturing a variable that something else will change is a shared reference, whether or not that was the intention.