M B A R K's Blog
What are Closures in C#?

What are Closures in C#?

M B A R K's photo
M B A R K
·

3 min read

Table of contents

Closures are a powerful feature in C# that allows you to reference variables within a block of code, even after the block of code has finished executing. This can be useful for creating and using anonymous functions, as well as for creating more complex control structures.

How do Closures work in C#?

In C#, closures are created using lambda expressions or anonymous methods. These are blocks of code that are defined inline and can be passed as arguments to other methods, or stored in variables for later use.

For example, consider the following code:

// Creates a list of integers from 1 to 10
var numbers = Enumerable.Range(1, 10);

// Filters the list to only include even numbers
var evenNumbers = numbers.Where(n => n % 2 == 0);

// Prints the even numbers to the console
foreach (var number in evenNumbers)
{
    Console.WriteLine(number);
}

Here, we use a closure to create a lambda expression that filters a list of numbers to only include even numbers. This lambda expression is passed to the Where method, which uses it to determine which elements to include in the resulting sequence.

Here are a couple of additional examples demonstrating the use of closures in C#:

Example 1: Creating and Using an Iterator

Closures can be used to create iterators, which are methods that return a sequence of values and can be used in a foreach loop.

For example, consider the following code:

public static IEnumerable<int> CountDown(int start)
{
    for (int i = start; i >= 0; i--)
    {
        yield return i;
    }
}

// Usage
foreach (var i in CountDown(5))
{
    Console.WriteLine(i);
}

// Output:
// 5
// 4
// 3
// 2
// 1
// 0

Here, we use the yield keyword to create an iterator that counts down from a given start value to 0. The yield keyword is used to specify the value to be returned by the iterator in each iteration of the foreach loop.

Example 2: Implementing a Loop with Multiple Exit Points

Closures can be used to implement more complex control structures, such as loops with multiple exit points.

For example, consider the following code:

int i = 0;

Action increment = () => i++;
Action breakLoop = null;

breakLoop = () =>
{
    if (i == 10)
    {
        return;
    }

    increment();
    breakLoop();
};

breakLoop();

Console.WriteLine(i); // Outputs "10"

Here, we define an Action delegate called increment that increments the value of i. We also define another Action delegate called breakLoop that calls itself recursively until the value of i reaches 10, at which point it exits.

The closure allows the breakLoop delegate to reference the value of i even after the delegate has finished executing, allowing it to continue incrementing the value of i in each recursive call.

Conclusion

Closures are a powerful feature in C# that allow you to reference variables within a block of code, even after the block of code has finished executing. They can be useful for creating and using anonymous functions, as well as for implementing more complex control structures.

C#