When does the scope of a disposable variable in a while loop end?

Question

I have a while loop wherein I do something with a memory stream - namely passing it to other objects that fill the stream or read from it. The code looks something like this:

public async void CaptureImages(CancellationToken ct)
{
    while(!ct.IsCancellationRequested)
    {
        await using var memoryStream = new MemoryStream();

        await this.camera.CaptureImage(memoryStream, ct);
        await this.storage.StoreImage(memoryStream, ct);
    }
}

My question is: Will memoryStream be disposed in every iteration or once the loop ends?

While the question C# 8 Using Declaration Scope Confusion answers this topic generally, it does not explicitly answer the question about the scope of disposable variables in a while-loop.

@Fildor Thanks for the remark. That was a typo in the while condition... — Spontifixus, Apr 02 '20 at 08:02
Also unrelated: Do you have a reason to make this `async void` instead of `async Task`? — Fildor, Apr 02 '20 at 08:05
Does this answer your question? [C# 8 Using Declaration Scope Confusion](https://stackoverflow.com/questions/59378228/c-sharp-8-using-declaration-scope-confusion) — Pavel Anikhouski, Apr 02 '20 at 08:12
@PavelAnikhouski only partly. I was explicitly confused about the while-loop. The answers showed me however that I did not think this through enough... ;) — Spontifixus, Apr 02 '20 at 08:18

score 6 · Answer 1 · answered Apr 02 '20 at 07:58

6

The memory stream will be disposed at the end of the while loop block, so once for every while loop iteration.

answered Apr 02 '20 at 07:58

Sean

60,939
11
97
136

score 4 · Accepted Answer · answered Apr 02 '20 at 08:05

Sean's answer is correct, but I wanted to expand a little bit to explain why it's correct:

This is actually a question about c#8 using declaration:

A using declaration is a variable declaration preceded by the using keyword. It tells the compiler that the variable being declared should be disposed at the end of the enclosing scope.

Basically, the using declaration is compiled as a using statement, that ends just before the enclosing scope ends. In other words, your code gets translated to this:

while(!ct.IsCancellationRequested)
{
    await using(var memoryStream = new MemoryStream())
    {
        await this.camera.CaptureImage(memoryStream, ct);
        await this.storage.StoreImage(memoryStream, ct);
    }
}

Now this is very clear when the memoryStream gets disposed - at the end of every while iteration.

Salah Akbari · Answer 3 · 2020-04-02T14:33:53.467

This is how your code will be executed (I've simplified your method to include just the necessary part):

public void CaptureImages(CancellationToken ct)
{
    while (!ct.IsCancellationRequested)
    {
        MemoryStream memoryStream = new MemoryStream();

        try
        {
        }

        finally
        {
            if (memoryStream != null)
            {
                ((IDisposable)memoryStream).Dispose();
            }
        }
    }
}

So as you can see, the memoryStream will be disposed in every iteration. You can find the intermediate steps and results of your code compilation here in SharpLap.

The link to sharpLab is invaluable! That's a handy resource! — Spontifixus, Apr 02 '20 at 08:49

When does the scope of a disposable variable in a while loop end?

3 Answers3