Why Lambda with captures (closures) in C Sharp (C#)? - Purpose & Use Cases

The Big Idea

What if your code could remember things for you, so you never mix up important details again?

The Scenario

Imagine you want to create a list of buttons in a program, and each button should remember its own number to show when clicked. Doing this manually means writing separate code for each button to remember its number.

The Problem

Writing separate code for each button is slow and boring. It's easy to make mistakes, like mixing up numbers or forgetting to update one button. If you want to change the behavior, you have to fix many places, which wastes time and causes bugs.

The Solution

Using lambda with captures lets you write one small piece of code that remembers the number automatically. This way, each button keeps its own number without extra work. It's like giving each button a little memory, so your code stays short, clear, and easy to change.

Before vs After

✗ Before

for (int i = 0; i < 3; i++) {
  int num = i;
  buttons[i].Click += delegate { Console.WriteLine(num); };
}

✓ After

for (int i = 0; i < 3; i++) {
  int num = i;
  buttons[i].Click += () => Console.WriteLine(num);
}

What It Enables

It enables writing simple, reusable code that remembers important values automatically, making programs easier to build and maintain.

Real Life Example

Think of a photo gallery app where each thumbnail remembers which photo it shows. Using lambda with captures, each thumbnail button can show the right photo without extra code for each one.

Key Takeaways

Manual code for remembering values is repetitive and error-prone.

Lambdas with captures let code remember values automatically.

This makes programs simpler, cleaner, and easier to update.

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