Lambda with captures (closures) in C Sharp (C#) - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a lambda expression in C#?

A lambda expression is a short way to write an anonymous function using the syntax (parameters) => expression or block. It can be used to create inline functions.

intermediate

What does it mean when a lambda "captures" a variable?

Capturing means the lambda uses a variable from its surrounding scope. The lambda keeps a reference to that variable, so it can use or change it even after the original scope ends.

intermediate

Explain what a closure is in C#.

A closure is a lambda or anonymous function that captures variables from its surrounding scope. It 'closes over' those variables, keeping them alive and accessible inside the lambda.

intermediate

Consider this code snippet:

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

What will be printed and why?

It will print 11. The lambda captures the variable x by reference, not by value. So when x changes to 10, the lambda uses the updated value.

beginner

Why are closures useful in programming?

Closures let you keep state inside functions without using classes or global variables. They help write cleaner, more flexible code by bundling data with behavior.

What does a lambda capture in C#?

A Nothing, lambdas cannot capture variables

B Only constants

C Only parameters passed to it

D Variables from its surrounding scope

Lambdas can capture variables from the surrounding scope, allowing them to access or modify those variables.

If a lambda captures a variable, what happens when the variable changes after the lambda is created?

A The lambda sees the updated value

B The lambda keeps the original value forever

C The lambda throws an error

D The lambda copies the value once and ignores changes

The lambda captures the variable by reference, so it sees any changes made to the variable after creation.

What is a closure in C#?

A A static method

B A lambda that captures variables from its environment

C A method with no parameters

D A class with private fields

A closure is a lambda or anonymous function that captures variables from its surrounding scope.

Which of these is a correct lambda syntax in C#?

A () => 42

B lambda() { return 42; }

C function() => 42

D def lambda(): return 42

The correct C# lambda syntax uses =>, for example: () => 42.

Why might you use a closure instead of a class?

A Because closures are faster than classes

B Because classes cannot hold state

C To keep state in a small, simple function without extra code

D Because closures do not use memory

Closures let you keep state inside a function without needing to create a full class, making code simpler and cleaner.

Describe how a lambda captures variables and what effect this has on variable values inside the lambda.

Think about what happens if the variable changes after the lambda is created.

Explain what a closure is and why it is useful in C# programming.

Closures bundle data and behavior together.

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