Thread safety in await IAsyncEnumerable<T>

[LeaFrock]

For example,

        List<string> failPathes = [];
        await foreach (var t in Task.WhenEach(files2Upload.Select(f => UploadAsync(f.path, f.file))))
        {
            var failPath = await t;
            if (failPath != string.Empty)
            {
                failPathes.Add(failPath);
                Logger.LogError("upload fail：{path}", failPath);
            }
        }
        return failPathes.Count == 0 ? string.Empty : $"upload failed files：{string.Join(';', failPathes)}";

Should the failPathes use a threading-safe collection like ConcurrentBag<string> rather than List<string>?

I guess NO after reading the source code of Task.WhenEach, while no guidance docs are found.

[stephentoub]

await foreach processes the loop body sequentially. It does not introduce any parallelism.

[LeaFrock]

Thanks. I think it'd be better to give a tip among the Docs.

[huoyaoyuan]

I don't think there is anything related to specific api. foreach or await foreach are just sequential constructs. It's not related to how the enumerated source is produced.

[LeaFrock]

Well, at least in the example I provided, the tasks executed by Task.WhenEach run in parallel, but they arrive at the await foreach one by one, turning the whole thing back into sequential processing. The first time I used it, that behavior felt unsettling—uncertain enough that I had to dig into the source or come here and ask.

I doubt I’m the only one who’s been tripped up by this?

[huoyaoyuan]

but they arrive at the await foreach one by one, turning the whole thing back into sequential processing

Not exactly. No matter how items arrives, await foreach always process items sequentially. The behavior of await foreach is:

while (await enumerator.MoveNextAsync())
{
    process(enumerator.Current);
}

It's not the following structure that registers callback for each item:

foreach (var task in tasks)
{
    task.ContinueWith(t => process(t));
}