Lambda with captures (closures) in C Sharp (C#)

Introduction

Lambdas with captures let you create small functions that remember values from outside their own code. This helps keep related data and behavior together.

When you want a quick function that uses variables from nearby code without passing them as parameters.

When you need to keep track of a changing value inside a small function, like counting or accumulating.

When you want to write cleaner code by avoiding extra classes or methods for simple tasks.

When you want to customize behavior on the fly, like sorting or filtering with specific rules.

Syntax

C Sharp (C#)

var lambda = () => expression;

// or with captures
int x = 5;
Func<int> lambdaWithCapture = () => x + 10;

Lambdas can access variables from the surrounding method or scope.

These captured variables are kept alive as long as the lambda exists.

Examples

This lambda captures variable a and adds 5 to it.

C Sharp (C#)

int a = 3;
Func<int> addFive = () => a + 5;
Console.WriteLine(addFive());

The lambda captures count and increases it each time it runs.

C Sharp (C#)

int count = 0;
Action increment = () => count++;
increment();
increment();
Console.WriteLine(count);

The lambda uses the captured prefix to create a greeting.

C Sharp (C#)

string prefix = "Hello";
Func<string, string> greet = name => prefix + ", " + name + "!";
Console.WriteLine(greet("Alice"));

Sample Program

This program shows a lambda that captures baseNumber. When baseNumber changes, the lambda uses the new value.

C Sharp (C#)

using System;

class Program
{
    static void Main()
    {
        int baseNumber = 10;
        Func<int, int> addBase = x => x + baseNumber;

        Console.WriteLine(addBase(5));  // 15

        baseNumber = 20;  // Change captured variable
        Console.WriteLine(addBase(5));  // 25
    }
}

Important Notes

Captured variables are not copied; the lambda uses the original variable.

Changing the captured variable affects all lambdas that capture it.

Be careful with captured variables in loops to avoid unexpected results.

Summary

Lambdas with captures remember variables from outside their code.

This helps write small, flexible functions without extra classes.

Captured variables stay alive as long as the lambda needs them.

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