Unexpected behaviour after disposing

[TomPeters]

Consider the following example

var enumerable = new AsyncEnumerable<int>(async yield =>
    {
        await yield.ReturnAsync(1);
        await yield.ReturnAsync(2);
        await yield.ReturnAsync(3);
    });
var enumerator = await enumerable.GetAsyncEnumeratorAsync();
await enumerator.MoveNextAsync();
enumerator.Dispose();
await enumerator.MoveNextAsync(); // What is the expected behavior here?

If you compare this to an IEnumerable that is disposable, such as the following:

IEnumerable<int> GetItems()
{
	using (var disposable = new Disposable())
	{
		yield return 1;
		yield return 2;
		yield return 3;
	}
}

This has the following behavior:

IEnumerable<int> enumerable = GetItems();
var enumerator = enumerable.GetEnumerator();
enumerator.MoveNext(); // true;
enumerator.Current; // 1
enumerator.Dispose();
enumerator.MoveNext(); // false;
enumerator.Current; // 1

So disposing the enumerator acts as if you had reached the end of the enumeration. Whereas if you do the same thing on an IAsyncEnumerator, it will actually restart the enumeration from the start, because the implementation of MoveNextAsync will lazily start enumeration if _yield and _enumerationTask are null, and they are both set to null during Dispose.

[kind-serge]

This is fixed in version 2.1.0