运行多个异步任务并等待它们全部完成

你想要链接__abc 0，还是可以以并行的方式调用它们?

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

并且不要忘记在每个ContinueWith中检查之前的Task实例，因为它可能有错误。

你可以创建很多任务，比如:

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


Task.WaitAll(TaskList.ToArray());

两个答案都没有提到可等待的Task.WhenAll:

var task1 = DoWorkAsync();
var task2 = DoMoreWorkAsync();


await Task.WhenAll(task1, task2);

Task.WaitAll和Task.WhenAll之间的主要区别是前者将阻塞(类似于在单个任务上使用Wait)，而后者不会阻塞，并且可以等待，将控制权交还给调用者，直到所有任务完成。

更重要的是，异常处理不同:

Task.WaitAll:

至少一个Task实例被取消了，或者在执行至少一个Task实例期间抛出了异常。如果一个任务被取消了，AggregateException的InnerExceptions集合中包含一个OperationCanceledException。

Task.WhenAll:

如果所提供的任何任务以故障状态完成，则返回的任务也将以故障状态完成，其中其异常将包含来自所提供的每个任务的未包装异常集的聚合。

如果提供的任务都没有错误，但至少有一个任务被取消，则返回的任务将以已取消状态结束。

如果没有一个任务发生故障，也没有一个任务被取消，产生的任务将以RanToCompletion状态结束。 如果提供的数组/枚举对象不包含任务，则返回的任务将在返回给调用方之前立即转换到RanToCompletion状态

我所见过的最佳选择是以下扩展方法:

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

这样叫它:

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

或者使用async lambda:

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

下面是我对数组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

你可以使用WhenAll，它将返回一个可等待的Task或WaitAll，它没有返回类型，并将阻止类似Thread.Sleep的进一步代码执行，直到所有任务完成、取消或出错。

例子

var tasks = new Task[] {
TaskOperationOne(),
TaskOperationTwo()
};


Task.WaitAll(tasks);
// or
await Task.WhenAll(tasks);

如果你想以特定的/特定的顺序运行任务，你可以从这 answer中得到灵感。

还有另一个答案……但我通常会遇到这样的情况，当我需要同时加载数据并将其放入变量中，比如:

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
}

我准备了一段代码，向您展示如何在这些场景中使用该任务。

    // 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);
}

应该有一个比公认的答案更简洁的解决方案。它不应该只用三步就能同时运行多个任务并获得结果。

1. 创建任务
2. 等待Task.WhenAll(任务)
3. 获取任务结果(例如task1.Result)

这里有一个方法，可以把这个问题简化为两个步骤:

    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);
}

你可以这样使用它:

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

这样就不需要临时任务变量了。使用它的问题是，虽然它适用于两个任务，但您需要为三个任务或任何其他数量的任务更新它。而且，如果其中一个任务没有返回任何东西，它也不能很好地工作。实际上，.Net库应该提供一些可以做到这一点的东西

如果你正在使用异步/等待模式，你可以像这样并行运行几个任务:

public async Task DoSeveralThings()
{
// Start all the tasks
Task first = DoFirstThingAsync();
Task second = DoSecondThingAsync();


// Then wait for them to complete
var firstResult = await first;
var secondResult = await second;
}