How Does Variable Capture Work in C# Closures?

Detailed explanation of variable capture in C# closures

Introduction

Variable capture is a fundamental aspect in C# closures that allows a closure to access variables defined within its enclosing scope. This article takes a deep dive into variable capture, answering specific questions about how it works, value type versus reference type capture, and boxing.

How local variables are captured

Variable capture occurs when a lambda expression or anonymous method accesses a local variable in its enclosing scope. However, the exact mechanism of capture is not obvious.

To understand this, let’s consider a simple example:

<code class="language-csharp">Action action = () => { Console.WriteLine(counter); };
int counter = 5;</code>

In this example, the lambda expression captures the variable counter in its enclosing scope. To accomplish this, the compiler actually creates an anonymous class, called a closure class, which stores a reference to the captured variable. When the lambda expression is executed, it accesses the captured variable through the closure class:

<code class="language-csharp">class ClosureClass
{
    private int counter;

    public ClosureClass(int counter)
    {
        this.counter = counter;
    }

    public void Execute()
    {
        Console.WriteLine(counter);
    }
}</code>

In this case, the closure class stores a reference to the variable counter and provides a method to access it.

Value types and reference types

The type of the captured variable determines how it is stored in the closure class:

• Value type: The value itself is stored in the closure class. There is no boxing or unboxing operations involved.
• Reference type: References to objects are stored in closure classes. If the object is later modified, the captured reference will reflect those changes.

Packing

No boxing is involved when capturing value types. The captured value is stored directly in the closure class, and the original variable can be modified without affecting the captured value.

The above is the detailed content of How Does Variable Capture Work in C# Closures?. For more information, please follow other related articles on the PHP Chinese website!