Lambda with captures (closures) in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Lambda with captures (closures)

Define variable x

↓

Create lambda capturing x

↓

Store lambda in a delegate

↓

Change x or call lambda

↓

Lambda uses captured x value

↓

Output result

This flow shows how a lambda captures a variable from its surrounding scope and uses it later when called.

Execution Sample

C Sharp (C#)

int x = 5;
Func<int> f = () => x + 10;
x = 7;
int result = f();
Console.WriteLine(result);

This code creates a lambda that adds 10 to x, then changes x, calls the lambda, and prints the result.

Execution Table

Step	Action	Variable x	Lambda f	Result	Output
1	Initialize x	5	null	null	null
2	Create lambda f capturing x	5	() => x + 10	null	null
3	Change x to 7	7	() => x + 10	null	null
4	Call lambda f()	7	() => x + 10	17	null
5	Print result	7	() => x + 10	17	17

💡 Program ends after printing the result 17

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
x	5	5	7	7	7
result	null	null	null	17	17

Key Moments - 2 Insights

Why does the lambda see the updated value of x (7) instead of the original (5)?

Because the lambda captures the variable x itself, not just its value at creation. So when x changes before calling the lambda (step 3), the lambda uses the current value (step 4).

What if we changed x after calling the lambda? Would the lambda output change?

No, because the lambda uses the value of x at the time it is called. Changes after calling do not affect past results (see step 4 and 5).

Visual Quiz - 3 Questions

Look at the execution table, what is the value of x when the lambda f is called at step 4?

A 5

B 7

C null

D 17

💡 Hint

Check the 'Variable x' column at step 4 in the execution_table.

At which step is the lambda f created capturing x?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look for the action 'Create lambda f capturing x' in the execution_table.

If we changed x to 10 after step 4 but before printing, what would the output be?

A 17

B 20

C 10

D null

💡 Hint

The lambda was already called at step 4 producing 17; changing x after does not affect that result.

Concept Snapshot

Lambda with captures (closures) in C#:
- Lambdas can capture variables from their surrounding scope.
- They capture the variable itself, not just its value at creation.
- When called, the lambda uses the current value of captured variables.
- Useful for deferred execution and preserving context.
- Syntax: Func<int> f = () => x + 10;

Full Transcript

This example shows how a lambda in C# captures a variable from outside its body. We start with x = 5. Then we create a lambda f that adds 10 to x. Next, we change x to 7. When we call f(), it uses the current value of x, which is 7, so the result is 17. Finally, we print 17. This demonstrates that lambdas capture variables by reference, not by value, so they see the latest value when called.

Practice

1.

What does it mean when a lambda expression captures a variable in C#?

easy

A. The lambda deletes the variable after execution.

B. The lambda remembers and uses the variable from outside its own code block.

C. The lambda creates a new variable with the same name inside its code.

D. The lambda can only use variables declared inside it.

Solution

1. Step 1: Understand lambda captures

   A lambda can use variables declared outside its own code block by capturing them.

2. Step 2: Effect of capturing

   This means the lambda remembers the variable's value and can use or modify it later.

3. Final Answer:

   The lambda remembers and uses the variable from outside its own code block. -> Option B

4. Quick Check:

   Lambda captures = remembers outside variables [OK]

Hint: Captured variables come from outside the lambda [OK]

Common Mistakes:

• Thinking lambda creates new variables instead of capturing
• Assuming variables are deleted after lambda runs
• Believing lambdas can't use outside variables

2.

Which of the following is the correct syntax to declare a lambda that captures an external variable count and increments it?

int count = 0;
var increment = ?;

easy

A. () => count++;

B. (int count) => count++;

C. () => { int count = 0; count++; };

D. count => count + 1;

Solution

1. Step 1: Identify lambda capturing external variable

   The lambda should use the external variable count without redeclaring it.

2. Step 2: Check syntax correctness

   () => count++; uses an empty parameter list and increments the external count variable correctly.

3. Final Answer:

   () => count++; -> Option A

4. Quick Check:

   Empty params and external variable increment [OK]

Hint: Use empty parentheses to capture external variables [OK]

Common Mistakes:

• Trying to redeclare captured variable inside lambda
• Using lambda parameters instead of capturing
• Incorrect lambda syntax with parameters

3.

What is the output of this C# code?

int x = 5;
Func<int> f = () => x * 2;
x = 10;
Console.WriteLine(f());

medium

A. Compile error

B. 10

C. 5

D. 20

Solution

1. Step 1: Understand variable capture behavior

   The lambda captures the variable x by reference, not by value.

2. Step 2: Evaluate the lambda call after changing x

   Since x was changed to 10 before calling f(), the lambda returns 10 * 2 = 20.

3. Final Answer:

   20 -> Option D

4. Quick Check:

   Captured variable reflects latest value [OK]

Hint: Captured variables reflect current value when lambda runs [OK]

Common Mistakes:

• Assuming lambda captures variable value at creation time
• Expecting output 5 or 10 instead of 20
• Thinking code causes compile error

4.

Identify the error in this code snippet involving a lambda with captures:

int total = 0;
var actions = new List<Action>();
for (int i = 0; i < 3; i++) {
    actions.Add(() => total += i);
}
actions.ForEach(a => a());
Console.WriteLine(total);

medium

A. The variable i is captured incorrectly, causing unexpected results.

B. The variable total cannot be captured by the lambda.

C. The lambda syntax is invalid and causes a compile error.

D. The list actions cannot store lambdas.

Solution

1. Step 1: Analyze variable capture in loop

   The lambda captures the loop variable i by reference, so all lambdas share the same i.

2. Step 2: Effect on final output

   After the loop, i is 3, so each lambda adds 3 to total, resulting in total = 9 instead of expected 0+1+2=3.

3. Final Answer:

   The variable i is captured incorrectly, causing unexpected results. -> Option A

4. Quick Check:

   Loop variable capture causes bugs [OK]

Hint: Loop variables captured by reference cause bugs [OK]

Common Mistakes:

• Thinking total can't be captured
• Believing lambda syntax is wrong
• Assuming list can't hold lambdas

5.

You want to create a list of lambdas that each print their own index from 0 to 2. Which code correctly captures the index variable?

var actions = new List<Action>();
for (int i = 0; i < 3; i++) {
    // Fill in here
}
actions.ForEach(a => a());

hard

A. actions.Add((int i) => Console.WriteLine(i));

B. actions.Add(() => Console.WriteLine(i));

C. int copy = i; actions.Add(() => Console.WriteLine(copy));

D. actions.Add(() => Console.WriteLine(0));

Solution

1. Step 1: Understand loop variable capture problem

   Directly capturing i causes all lambdas to print the final value of i (3).

2. Step 2: Use a local copy to capture each index

   Declaring copy = i inside the loop creates a new variable for each iteration, which the lambda captures correctly.

3. Final Answer:

   int copy = i; actions.Add(() => Console.WriteLine(copy)); -> Option C

4. Quick Check:

   Use local copy to capture loop variable [OK]

Hint: Copy loop variable inside loop before lambda [OK]

Common Mistakes:

• Capturing loop variable directly causing all lambdas to print same value
• Trying to add lambda with parameter in Add method
• Hardcoding constant instead of variable