Running multiple async tasks and waiting for them all to complete

You could create many tasks like:

List<Task> TaskList = new List<Task>(); foreach(...) { var LastTask = new Task(SomeFunction); LastTask.Start(); TaskList.Add(LastTask); } Task.WaitAll(TaskList.ToArray()); 

You can use WhenAll which will return an awaitable Task or WaitAll which has no return type and will block further code execution simular to Thread.Sleep until all tasks are completed, canceled or faulted.

Example

var tasks = new Task[] { TaskOperationOne(), TaskOperationTwo() }; Task.WaitAll(tasks); // or await Task.WhenAll(tasks); 

If you want to run the tasks in a particular/specific order you can get inspiration from this answer.

The best option I've seen is the following extension method:

public static Task ForEachAsync<T>(this IEnumerable<T> sequence, Func<T, Task> action) { return Task.WhenAll(sequence.Select(action)); } 

Call it like this:

await sequence.ForEachAsync(item => item.SomethingAsync(blah)); 

Or with an async lambda:

await sequence.ForEachAsync(async item => { var more = await GetMoreAsync(item); await more.FrobbleAsync(); }); 

Yet another answer...but I usually find myself in a case, when I need to load data simultaneously and put it into variables, like:

var cats = new List<Cat>(); var dog = new Dog(); var loadDataTasks = new Task[] { Task.Run(async () => cats = await LoadCatsAsync()), Task.Run(async () => dog = await LoadDogAsync()) }; try { await Task.WhenAll(loadDataTasks); } catch (Exception ex) { // handle exception } 

Do you want to chain the Tasks, or can they be invoked in a parallel manner?

For chaining
Just do something like

Task.Run(...).ContinueWith(...).ContinueWith(...).ContinueWith(...); Task.Factory.StartNew(...).ContinueWith(...).ContinueWith(...).ContinueWith(...); 

and don't forget to check the previous Task instance in each ContinueWith as it might be faulted.

For the parallel manner
The most simple method I came across: Parallel.Invoke Otherwise there's Task.WaitAll or you can even use WaitHandles for doing a countdown to zero actions left (wait, there's a new class: CountdownEvent), or ...

This is how I do it with an array Func<>:

var tasks = new Func<Task>[] { () => myAsyncWork1(), () => myAsyncWork2(), () => myAsyncWork3() }; await Task.WhenAll(tasks.Select(task => task()).ToArray()); //Async Task.WaitAll(tasks.Select(task => task()).ToArray()); //Or use WaitAll for Sync 

might like to take a look at below link which explains which explains best practice for await async. https://learn.microsoft.com/en-us/dotnet/csharp/asynchronous-programming/async-scenarios

Use this... Instead of this... When wishing to do this... await Task.Wait Task.Result Retrieving the result of a background task await Task.WhenAny Task.WaitAny Waiting for any task to complete await Task.WhenAll Task.WaitAll Waiting for all tasks to complete await Task.Delay Thread.Sleep Waiting for a period of time 

Since .net-9.0 there is another convenient option present - Task.WhenEach which allows to process the tasks upon completion:

Creates an IAsyncEnumerable<T> that will yield the supplied tasks as those tasks complete.

int[] delays = [100, 50, 0]; var tasksToRun = delays .Select(async (delay, index) => { await Task.Delay(delay); return (index, delay); }); var sw = Stopwatch.StartNew(); await foreach (var completed in Task.WhenEach(tasksToRun)) { Console.Write($"{completed.Status} "); var result = completed.Result; Console.WriteLine($"index: {result.index} delay: {result.delay} elapsed: {sw.ElapsedMilliseconds}ms"); } 

Which prints "on my machine":

RanToCompletion index: 2 delay: 0 elapsed: 27ms RanToCompletion index: 1 delay: 50 elapsed: 57ms RanToCompletion index: 0 delay: 100 elapsed: 102ms 

I prepared a piece of code to show you how to use the task for some of these scenarios.

 // method to run tasks in a parallel public async Task RunMultipleTaskParallel(Task[] tasks) { await Task.WhenAll(tasks); } // methode to run task one by one public async Task RunMultipleTaskOneByOne(Task[] tasks) { for (int i = 0; i < tasks.Length - 1; i++) await tasks[i]; } // method to run i task in parallel public async Task RunMultipleTaskParallel(Task[] tasks, int i) { var countTask = tasks.Length; var remainTasks = 0; do { int toTake = (countTask < i) ? countTask : i; var limitedTasks = tasks.Skip(remainTasks) .Take(toTake); remainTasks += toTake; await RunMultipleTaskParallel(limitedTasks.ToArray()); } while (remainTasks < countTask); } 

There should be a more succinct solution than the accepted answer. It shouldn't take three steps to run multiple tasks simultaneously and get their results.

1. Create tasks
2. await Task.WhenAll(tasks)
3. Get task results (e.g., task1.Result)

Here's a method that cuts this down to two steps:

 public async Task<Tuple<T1, T2>> WhenAllGeneric<T1, T2>(Task<T1> task1, Task<T2> task2) { await Task.WhenAll(task1, task2); return Tuple.Create(task1.Result, task2.Result); } 

You can use it like this:

var taskResults = await Task.WhenAll(DoWorkAsync(), DoMoreWorkAsync()); var DoWorkResult = taskResults.Result.Item1; var DoMoreWorkResult = taskResults.Result.Item2; 

This removes the need for the temporary task variables. The problem with using this is that while it works for two tasks, you'd need to update it for three tasks, or any other number of tasks. Also it doesn't work well if one of the tasks doesn't return anything. Really, the .Net library should provide something that can do this