Coding Bolt

In the world of C#, lambda expressions are an indispensable tool. They offer concise syntax and can make our code more expressive. However, when used within loops or async contexts, they can sometimes lead to unexpected behaviors due to variable capturing. In this post, we’ll explore what variable capturing means and how to prevent common pitfalls associated with it.

1. Basics of Lambda Expressions

Lambda expressions are a concise way to write inline, anonymous function definitions. They come in handy in numerous scenarios, especially when using LINQ or any other high-order function:

var numbers = new[] { 1, 2, 3, 4, 5 };
var evenNumbers = numbers.Where(n => n % 2 == 0);

In this example, n => n % 2 == 0 is a lambda expression that defines a function.

2. Captured Variables: The Problem Illustrated

The challenge arises when lambdas capture variables from an outer scope:

List<Action> actions = new List<Action>(5);

for (int i = 0; i < 5; i++)
{
    actions.Add(() => Console.WriteLine(i));
}

foreach (var action in actions)
{
    action(); // Prints 5, five times!
}

The expected output might be “0, 1, 2, 3, 4”, but it prints “5” five times. This is due to variable capturing.

When a lambda expression captures a variable, it actually captures a reference to the variable, not its current value. This means that if the variable’s value changes after the lambda is defined, the lambda sees the changed value when it’s invoked.

3. Solutions to the Capturing Problem

To fix the problem, we typically make a copy of the loop variable:

for (int i = 0; i < 5; i++)
{
    int copy = i;
    actions.Add(() => Console.WriteLine(copy));
}

This way, every iteration of the loop gets its own local variable, which is not modified by subsequent iterations.

Lambda expressions are powerful and expressive, but it’s essential to be aware of how they interact with surrounding variables. Understanding the nuances of variable capturing helps in writing bug-free and maintainable code. Always be cautious when capturing loop or mutable variables in lambdas, and consider the longevity and lifecycle of those variables in your logic.