23

I have a question regarding deferred execution and the disposing of data.

Consider the following example:

private IEnumerable<string> ParseFile(string fileName)
{
    using(StreamReader sr = new StreamReader(fileName))
    {
        string line;
        while((line = sr.ReadLine()) != null)
        {
            yield return line;
        }
    }
}

private void LineReader(string fileName)
{
    int counter = 0;

    foreach(string line in ParseFile(fileName))
    {
        if(counter == 2)
        {
            break; // will this cause a dispose on the StreamReader?
        } else
        {
            Console.WriteLine(line);
            counter++;
        }
    }
}

Will the break statement immediately cause the reader in ParseFile to dispose or is it still considered in context and will lock the file open until the program itself is closed?

Robert Harvey
  • 178,213
  • 47
  • 333
  • 501
Middas
  • 1,862
  • 1
  • 29
  • 44
  • 2
    Write a quick console app and find out :) – jjxtra Jan 07 '13 at 21:03
  • Oh a side note, rather than using `break` when the counter hits two, just add a `Take(2)` to the end of `ParseFile`. – Servy Jan 07 '13 at 21:12
  • 1
    Pick up Jon Skeet's book "C# in Depth" if you want a really good explanation of what happens in iterator blocks, or just look over the language spec, as he often suggests. – Eric Andres Jan 07 '13 at 21:31
  • 1
    @Servy Your answer below was exactly what I was looking for. I know that there are many better methods of pulling only 2 lines from a file. That was just a quick example to show what I was trying to get at. Thank you again for your help! – Middas Jan 07 '13 at 22:46

1 Answers1

20

So we have several separate issues going on here.

First off, dealing with the using in the iterator block. IEnumerator extends IDisposable. The code that generates iterator blocks is actually robust enough that any try/finally blocks (a using results in a try/finally block being created) results in the contents of the finally block being called in the Dispose method of the enumerator, if it wasn't already called. So as long as the enumerator is disposed, it won't leak the StreamReader.

So now we ask ourselves if the enumerator is disposed. All foreach statements will call Dispose on the enumerator (should it implement IDisposable). They do so even if you exit using a break or return statement, as well as when it finishes normally.

So you can be sure that under all circumstances the resource won't be leaked, barring the cases where nothing can be prevented from leaking (i.e. someone unpugging the machine).

Servy
  • 202,030
  • 26
  • 332
  • 449
  • It's a little more complicated than that. In the OP's case, the iterator will absolutely dispose becuase of the break statement. But the call to ParseFile produces a reference to StreamReader inside a 'local-using' that has now gone out of scope. I think this queues it up on the finalizer queue and disposed when collected? – n8wrl Jan 07 '13 at 21:14
  • 3
    @n8wrl No, that's not true. When the `IEnumerator` is disposed by the `foreach` loop it will call dispose on the `StreamReader` (assuming it was inside of the `using` at that point). It's the way iterator blocks were implemented; to make doing this possible. – Servy Jan 07 '13 at 21:15
  • I guess we should take PsychoDad's advice and try it out becuase that would be very cool if that's how it works! – n8wrl Jan 07 '13 at 21:16
  • 3
    Trying to find the specific quote, but you can start reading in case you get there quicker. http://blogs.msdn.com/b/ericlippert/archive/2009/07/16/iterator-blocks-part-three-why-no-yield-in-finally.aspx Pretty sure it'll be the most relevant, or the one after that, of the seven part series. – Servy Jan 07 '13 at 21:17