Introduction

Getting a second IAsyncEnumerator from the same IAsyncEnumerable is only safe when the source is replayable by design. Some async sequences are just iterator methods and can be enumerated again, while others wrap one-shot producers such as channels, sockets, or live streams where a second enumeration is meaningless or actively harmful.

Why a Second Enumeration Is Not Guaranteed

IAsyncEnumerable describes an async sequence interface, not a replay guarantee. Calling GetAsyncEnumerator twice only means you asked for two enumerators. It does not promise that the underlying producer can rewind or duplicate itself.

Consider a replayable iterator method:

1public static async IAsyncEnumerable<int> Replayable()
2{
3    for (var i = 0; i < 3; i++)
4    {
5        await Task.Delay(10);
6        yield return i;
7    }
8}

Each enumeration reruns the method body, so two enumerators work, but they also repeat the upstream work.

That is very different from a source backed by a channel or a live network feed. In those cases, the data may be consumed only once.

Where Task.WhenEach Changes the Conversation

Task.WhenEach is useful when you already have a collection of tasks and want to observe completions as they happen. If those tasks are coming from a lazy async sequence, a second enumeration can cause duplicate task creation or inconsistent behavior.

That is why the safest pattern is often to materialize once.

1using System.Collections.Generic;
2using System.Threading.Tasks;
3
4List<Task<int>> tasks = await source.ToListAsync(cancellationToken);
5
6await foreach (Task<int> completed in Task.WhenEach(tasks))
7{
8    Console.WriteLine(await completed);
9}

Now the task set is stable. You are no longer depending on the source sequence to be re-enumerable.

Materialize Once When You Need Reuse

If you need more than one pass, buffering is usually the clearest solution.

1using System.Collections.Generic;
2using System.Threading;
3using System.Threading.Tasks;
4
5public static async Task<IReadOnlyList<T>> BufferAsync<T>(
6    IAsyncEnumerable<T> source,
7    CancellationToken cancellationToken)
8{
9    var list = new List<T>();
10
11    await foreach (var item in source.WithCancellation(cancellationToken))
12    {
13        list.Add(item);
14    }
15
16    return list;
17}

Once buffered, the results can be reused safely without re-triggering the original producer.

Fan-Out From One Enumeration for Live Sources

If the source is live and you need multiple downstream consumers, read the source once and distribute the items yourself. A channel is a good fit for that pattern.

1using System.Threading.Channels;
2
3var channel = Channel.CreateUnbounded<int>();
4
5_ = Task.Run(async () =>
6{
7    await foreach (var item in source)
8    {
9        await channel.Writer.WriteAsync(item);
10    }
11
12    channel.Writer.Complete();
13});
14
15await foreach (var item in channel.Reader.ReadAllAsync())
16{
17    Console.WriteLine(item);
18}

That design makes the ownership explicit: one component enumerates the original source, and other components consume the distributed results.

Enumerator Lifetime Still Matters

If you manage the enumerator manually, dispose it properly with await using.

1await using var enumerator = source.GetAsyncEnumerator(cancellationToken);
2
3while (await enumerator.MoveNextAsync())
4{
5    Console.WriteLine(enumerator.Current);
6}

Async enumerators can hold onto resources such as sockets, file handles, or channel registrations. Forgetting disposal can create subtle leaks.

How to Decide What Is Safe

It is safe to enumerate twice only when all of these are true:

• the source contract is replayable,
• repeated upstream work is acceptable,
• repeated side effects are acceptable,
• the source is not a one-shot live feed.

If any of those conditions are false, do not rely on a second enumerator. Materialize once or build a fan-out layer.

Common Pitfalls

A common mistake is assuming every IAsyncEnumerable behaves like a regular in-memory collection. It does not. Many async sequences are closer to pipelines or subscriptions than to lists.

Another issue is re-enumerating a source that creates tasks lazily. In a Task.WhenEach workflow, that can accidentally launch duplicate work instead of reusing the original tasks.

Developers also sometimes buffer without thinking about size. Materialization is a great tool for bounded sequences, but it can become a memory problem for very large or unbounded streams.

Summary

• A second IAsyncEnumerator is safe only when the source is replayable by design.
• 'IAsyncEnumerable itself does not guarantee rewind or duplication semantics.'
• For Task.WhenEach, materializing the tasks once is often the safest pattern.
• For live one-shot sources, fan out from a single enumeration instead of re-enumerating.
• Dispose async enumerators properly and think about memory before buffering large streams.