Why are closures different for variables from C# 8.0 using declarations?

Question

I've noticed a difference in the way the C# 8.0 compiler builds closure classes for captured IDisposable variables that are declared with a C# 8.0 using declaration, as opposed to variables declared with the classic using statement.

Consider this simple class:

public class DisposableClass : IDisposable
{
    public void Dispose() { }
}

And this sample code:

public void Test()
{
    using var disposable1 = new DisposableClass();
    using var disposable2 = new DisposableClass();

    Action action = () => Console.Write($"{disposable1}{disposable2}");
}

The compiler generates this code:

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
    public DisposableClass disposable1;

    public DisposableClass disposable2;

    internal void <Test>b__0()
    {
        Console.Write(string.Format("{0}{1}", disposable1, disposable2));
    }
}

public void Test()
{
    <>c__DisplayClass0_0 <>c__DisplayClass0_ = new <>c__DisplayClass0_0();
    <>c__DisplayClass0_.disposable1 = new DisposableClass();
    try
    {
        <>c__DisplayClass0_.disposable2 = new DisposableClass();
        try
        {
            Action action = new Action(<>c__DisplayClass0_.<Test>b__0);
        }
        finally
        {
            if (<>c__DisplayClass0_.disposable2 != null)
            {
                ((IDisposable)<>c__DisplayClass0_.disposable2).Dispose();
            }
        }
    }
    finally
    {
        if (<>c__DisplayClass0_.disposable1 != null)
        {
            ((IDisposable)<>c__DisplayClass0_.disposable1).Dispose();
        }
    }
}

This looks perfectly ok. But then I noticed that if I declare those two variables with a using statement, the closure class is generated pretty differently. This is the sample code:

public void Test()
{
    using (var disposable1 = new DisposableClass())
    using (var disposable2 = new DisposableClass())
    {
        Action action = () => Console.Write($"{disposable1}{disposable2}");
    }
}

And this is what I get:

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
    public DisposableClass disposable1;
}

[CompilerGenerated]
private sealed class <>c__DisplayClass0_1
{
    public DisposableClass disposable2;

    public <>c__DisplayClass0_0 CS$<>8__locals1;

    internal void <Test>b__0()
    {
        Console.Write(string.Format("{0}{1}", CS$<>8__locals1.disposable1, disposable2));
    }
}

Why does this happen? The rest of the code looks identical, and I thought that a using declaration was supposed to be exactly the same as a using statement that considered as block the current block it's declared within.

Not to mention that the way the closure class is generated for using declarations looks way clearer, and most importantly, much easier to explore through reflection.

I'd love some insights, if anyone knows why this is happening.

Thanks!

Answer 1

The compiler is generating a [CompilerGenerated] class for each "scope"... In the first example, there is a single scope, the whole Test() method. In the second example (that you don't give), there are two scopes, the two using.

The code of the second example is probably:

public void Test()
{
    using (var disposable1 = new DisposableClass())
    {
        using (var disposable2 = new DisposableClass())
        {
            Action action = () => Console.Write($"{disposable1}{disposable2}");
        }
    }
}

As noted by juharr, these two blocks of code produce the same code:

using (DisposableClass disposable1 = new DisposableClass(), disposable2 = new DisposableClass())
{
    Action action = () => Console.Write($"{disposable1}{disposable2}");
}

and

using var disposable1 = new DisposableClass();
using var disposable2 = new DisposableClass();

Action action = () => Console.Write($"{disposable1}{disposable2}");