How is a struct on the heap deallocated?

Question

When I capture an int in a lambda, I guess it's allocated in the heap, to prevent deallocation at the end of the block. Then, how/when is it deallocated? Is the value boxed (then it must work like any other reference)? Is there a special functionality in the GC to manage structs on the heap?

Answer 1

When a local variable is captured in the lambda, it becomes a regular field in the compiler-generated lambda class. For example, this:

static void Main(string[] args) {
    int capture = 5;
    Func<int, int> func = input => input * capture;
}

Can be lowered by a C# compiler to this:

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
    public int capture;
    internal int <Main>b__0(int input)
    {
        return input * this.capture;
    }
}
private static void Main(string[] args)
{
    new C.<>c__DisplayClass0_0().capture = 5;
}

Thus:

Then, how/when is it deallocated?

It is deallocated just like a regular value type field of a class instance, when the class instance is deallocated.

Is the value boxed (then it must work like any other reference)?

In general, we use boxing to refer to the implicit representation-changing conversion of a value type to a special reference type whose only function is to (later) enable non-representation changing assignments of the original value to reference type locations (typically of type object or any interface type that the original value type implemented). Under the hood, boxing is performed by the CLR using a special IL instruction.

In the context of lambdas, even though the value probably goes to the heap as a field of a class instance, we don't call it boxing in the regular sense. Under the hood, capturing a variable is something that the C# compiler takes care of, by writing some equivalent boilerplate code for you.

Of course, as pointed out in the comments, in the end they both boil down to the same thing: they allocate a struct on the heap.

Is there a special functionality in the GC to manage structs on the heap?

Nothing special is required for lambda captures specifically. The GC already knows how to deallocate value type fields.