'yield' enumerations that don't get 'finished' by caller - what happens

Question

suppose I have

IEnumerable<string> Foo() {      try      {           /// open a network connection, start reading packets          while(moredata)          {             yield return packet;          }      }      finally       {         // close connection        } } 

(Or maybe I did a 'using' - same thing). What happens if my caller goes

var packet = Foo().First(); 

I am just left with a leaked connection. When does the finally get invoked? Or does the right thing always happen by magic

edit with answer and thoughts

My sample and other 'normal' (foreach, ..) calling patterns will work nicely because they dispose of the IEnumerable (actually the IEnumerator returned by GetEnumerator). I must therefore have a caller somewhere thats doing something funky (explicitly getting an enumerator and not disposing it or the like). I will have them shot

the bad code

I found a caller doing

IEnumerator<T> enumerator = foo().GetEnumerator(); 

changed to

using(IEnumerator<T> enumerator = foo().GetEnumerator()) 

Answer 1

I am just left with a leaked connection.

No, you're not.

When does the finally get invoked?

When the IEnumerator<T> is disposed, which First is going to do after getting the first item of the sequence (just like everyone should be doing when they use an IEnumerator<T>).

Now if someone wrote:

//note no `using` block on `iterator` var iterator = Foo().GetEnumerator(); iterator.MoveNext(); var first = iterator.Current; //note no disposal of iterator 

then they would leak the resource, but there the bug is in the caller code, not the iterator block.

Answer 2

You would not end up with leaked connection. Iterator objects produced by yield return are IDisposable, and LINQ functions are careful to ensure proper disposal.

For example, First() is implemented as follows:

public static TSource First<TSource>(this IEnumerable<TSource> source) {     if (source == null) throw Error.ArgumentNull("source");     IList<TSource> list = source as IList<TSource>;     if (list != null) {         if (list.Count > 0) return list[0];     }     else {         using (IEnumerator<TSource> e = source.GetEnumerator()) {             if (e.MoveNext()) return e.Current;         }     }     throw Error.NoElements(); } 

Note how the result of source.GetEnumerator() is wrapped in using. This ensures the call to Dispose, which in turn ensures the call of your code in the finally block.

Same goes for iterations by foreach loop: the code ensures disposal of the enumerator regardless of whether the enumeration completes or not.

The only case when you may end up with leaked connection is when you call GetEnumerator yourself, and fail to properly dispose of it. However, this is a mistake in the code using IEnumerable, not in the IEnumerable itself.