Composing tasks: WhenAll, WhenAny and WhenEach

Three price quotes that arrive after 300, 100 and 200 ms can be read in three ways: all of them at once after 300 ms, the first one after 100 ms, or each one as it arrives, at 100, 200 and 300 ms. Task.WhenAll, Task.WhenAny and Task.WhenEach are those three ways, and each returns something you await.

You will combine running tasks with each of them, read a recorded run of all three side by side, and see where WaitAsync puts a limit on the wait.

WhenAll waits for every task and keeps the order you gave

whenall.cs starts three quote calls, then awaits Task.WhenAll of the three tasks. Each call prints when its answer arrives:

// Task.WhenAll: one task that completes when every task given to it has completed. Its result is an array of the
// results, in the order the tasks were passed, whatever order they finished in.
Task<int> north = QuoteAsync("north", 412, 300);
Task<int> south = QuoteAsync("south", 398, 100);
Task<int> east = QuoteAsync("east", 405, 200);

int[] prices = await Task.WhenAll(north, south, east);
Console.WriteLine($"WhenAll gave [{string.Join(", ", prices)}]: north, south, east, the order they were passed");
Console.WriteLine($"cheapest: {prices.Min()}");

// The same with a list of tasks built in a loop: ToList() starts every call before WhenAll waits.
string[] vendors = ["north", "south", "east"];
List<Task<int>> calls = vendors.Select((v, i) => QuoteAsync(v, 400 + i, 100 * (3 - i))).ToList();
int[] fromList = await Task.WhenAll(calls);
Console.WriteLine($"from a list of {calls.Count} tasks: [{string.Join(", ", fromList)}]");

static async Task<int> QuoteAsync(string vendor, int price, int milliseconds)
{
    await Task.Delay(milliseconds);
    Console.WriteLine($"  {vendor} answered after {milliseconds} ms");
    return price;
}

  south answered after 100 ms
  east answered after 200 ms
  north answered after 300 ms
WhenAll gave [412, 398, 405]: north, south, east, the order they were passed
cheapest: 398
  east answered after 100 ms
  south answered after 200 ms
  north answered after 300 ms
from a list of 3 tasks: [400, 401, 402]

The answers arrived south, east, north, after 100, 200 and 300 ms, but WhenAll gave [412, 398, 405], the order of north, south and east as they were passed. WhenAll returns one task that completes when every task given to it has completed, and for Task<int> tasks its result is an int[] in the order of the arguments, so the code can match each price to its vendor by position. The whole wait took as long as the slowest call.

The second half builds the tasks with LINQ. ToList() runs the Select at once, so every call has started before WhenAll waits; Microsoft’s guide to async scenarios asks for ToList() or ToArray() here, because a lazy query would start nothing until something read it. When a task fails, WhenAll still waits for the others, its task ends Faulted with every exception, and await throws the first of them.

WhenAny returns the first task to finish, WhenEach every task as it finishes

three_ways.cs reads three waits of 300, 100 and 200 ms with each way in turn. Each task’s result is its own delay:

// Three tasks that finish after 300, 100 and 200 ms, read three ways. Each task's result is its own delay.
Task<int>[] Start() => [Wait(300), Wait(100), Wait(200)];

// WhenAny: the first task to finish, as a task. Await it again to get its result (or its exception).
Task<int> first = await Task.WhenAny(Start());
Console.WriteLine($"WhenAny: the first task to finish waited {await first} ms");

// WhenEach (.NET 9): every task, in the order they finish, as an async stream.
await foreach (Task<int> done in Task.WhenEach(Start()))
{
    Console.WriteLine($"WhenEach: a task finished, it waited {await done} ms");
}

// WhenAll: every result, in the order the tasks were passed.
int[] all = await Task.WhenAll(Start());
Console.WriteLine($"WhenAll: [{string.Join(", ", all)}], in the order they were passed");

static async Task<int> Wait(int milliseconds)
{
    await Task.Delay(milliseconds);
    return milliseconds;
}

WhenAny: the first task to finish waited 100 ms
WhenEach: a task finished, it waited 100 ms
WhenEach: a task finished, it waited 200 ms
WhenEach: a task finished, it waited 300 ms
WhenAll: [300, 100, 200], in the order they were passed

WhenAny completed as soon as the 100 ms task did, and its result is that task itself, which the code awaited again to get 100. WhenEach, new in .NET 9, gave every task in the order it finished, 100, 200, 300, as an async streamasync stream: A sequence whose items arrive asynchronously, typed IAsyncEnumerable<T>. An async iterator produces it with yield return, and await foreach reads it one item at a time. More in “Async streams with IAsyncEnumerable” read with await foreach, so each result could be used the moment it existed. WhenAll gave [300, 100, 200], the order of the arguments. Step through the 300 ms:

The four ways to wait for tasks, side by side:

WaitAsync, added in .NET 6, limits how long one wait may take. It ends the waiting when the limit passes, while the task it waited for runs on to its own end. Before .NET 6 the same limit was written as a race between the task and a Task.Delay, read with WhenAny. A limit that must stop the work itself is given to the work, as a cancellation token.

Failures in WhenAll and WhenAny, reproduced and handled Pro: opens with a Pro, Premium or Ultimate pass

Timeouts with WaitAsync, measured, and the work that keeps running Pro: opens with a Pro, Premium or Ultimate pass

A lab: the first 10 seats from five zones, within a time limit Pro: opens with a Pro, Premium or Ultimate pass

Practise

The self-check covers the first two sections: the order WhenAll keeps, what WhenAny gives back, and the order WhenEach follows. It begins with the method your answers so far show you know least, and gives the reason behind every choice, right or wrong:

Interview questions

Fresher · What does Task.WhenAll return, and in what order are its results?

Task.WhenAll returns one task that completes when every task passed to it has completed. For tasks that return values, Task<T>, the combined task’s result is a T[] holding each task’s result in the order the tasks were passed, not the order they finished: three quotes that finished south, east, north still come back as north, south, east. If any task fails, the combined task ends faulted after all of them have completed, and awaiting it throws the first exception. WhenAll starts nothing itself: the tasks were already running, so the total time is that of the slowest.

Key takeaways

• Task.WhenAll completes when every task has completed and gives their results in the order they were passed; the total time is the slowest task’s.
• Task.WhenAny completes with the first task to finish, which may be a failed one, so its result is awaited again.
• Task.WhenEach, new in .NET 9, gives every task as it finishes, as an async stream for await foreach.
• WaitAsync limits how long a wait lasts, while the task it waits for runs on to its own end.