Understanding C# Closures: Maintaining State Beyond Function Execution

Closures are a powerful feature in C# that allow you to capture and maintain the state of variables even after the enclosing function has finished executing. In this blog post, we’ll explore how closures work in C# and delve into the internal mechanics of how the code is transformed during the compilation process.

Closures in C#

Closures play a crucial role in functional programming and provide a way to access variables from an enclosing scope within an inner function. They enable the retention of variable state, which can be incredibly useful in various programming scenarios.

Let’s consider an example scenario of creating a counter using closures:

public class Program
{
    public static Action CreateCounter()
    {
        int count = 0;
        return () =>
        {
            count++;
            Console.WriteLine($"Current count: {count}");
        };
    }

    public static void Main(string[] args)
    {
        Action counter = CreateCounter();
        counter();
        counter();
    }
}

In this example, we define a CreateCounter function that returns an Action delegate. The CreateCounter function declares a local variable count and returns an anonymous function that captures and increments the count variable.

When we execute the code in the Main method, we create an instance of the counter using CreateCounter and assign it to the counter variable. Invoking counter multiple times demonstrates that the count variable maintains its state across invocations.

To understand the internals of closures, we need to explore the compilation process and how the code is transformed. During the compilation, closures are “lowered” into a form that the underlying runtime can execute efficiently. Let’s examine the lowered code for the CreateCounter function:

private sealed class DisplayClass0
{
    public int count;

    public void IncrementCount()
    {
        count++;
        Console.WriteLine($"Current count: {count}");
    }
}

public static Action CreateCounter()
{
    DisplayClass0 displayClass = new DisplayClass0();
    displayClass.count = 0;
    return new Action(displayClass.IncrementCount);
}

In the lowered code, a new class named DisplayClass0 is generated to hold the captured state. The IncrementCount method within the class represents the anonymous function that increments the count and displays the current count value.

By examining the lowered code, we can see how the state is maintained through the count field of the DisplayClass0 instance.

Closures in Functional Programming

Functional programming emphasizes the use of pure functions that don’t rely on mutable state or side effects. However, there are scenarios where maintaining state becomes necessary. This is where closures shine. They allow functional programming paradigms to coexist with stateful operations.

Closures enable the creation of higher-order functions that take other functions as arguments or return functions as results. By capturing variables from their enclosing scope, closures make it possible for functions to carry their context with them, even when they are invoked elsewhere.

Let’s consider an example scenario of filtering a list of integers using a lambda expression with closure:

public static void Main(string[] args)
{
    List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
    int threshold = 5;

    Func<int, bool> filterFunc = number => number > threshold;
    List<int> filteredNumbers = numbers.Where(filterFunc).ToList();

    Console.WriteLine("Filtered numbers greater than {0}:", threshold);
    foreach (int number in filteredNumbers)
    {
        Console.WriteLine(number);
    }
}

In this example, we have a list of numbers and a threshold value. We define a lambda expression number => number > threshold that acts as a filter function. The lambda expression captures the threshold variable from its enclosing scope, forming a closure. The closure enables the lambda expression to access and compare each number with the captured threshold value.
By using the closure-powered lambda expression with the Where method, we filter the numbers greater than the threshold and obtain a new list of filtered numbers. Finally, we print the filtered numbers to the console.

The closure allows the lambda expression to maintain a reference to the threshold variable, even after it goes out of scope. This enables the lambda expression to access the threshold value whenever it’s invoked, ensuring the correct filtering behavior.

Closures are an essential tool in functional programming and C#, enabling the creation of functions that maintain state and can be used as first-class citizens. By capturing variables from their enclosing scope, closures facilitate the coexistence of functional and stateful operations. Understanding closures not only empowers you to write expressive code but also unlocks the full potential of functional programming paradigms in C#.