C# 多个等待vs Task.WaitAll-等效？

就性能而言，这两个方法是否会并行运行

GetAllWidgets（）

和

GetAllFoos（）

有什么理由用一个代替另一个吗？编译器的幕后似乎发生了很多事情，所以我不太清楚

============方法A:使用多个等待======================

public async Task<IHttpActionResult> MethodA()
{
    var customer = new Customer();

    customer.Widgets = await _widgetService.GetAllWidgets();
    customer.Foos = await _fooService.GetAllFoos();

    return Ok(customer);
}

public async Task<IHttpActionResult> MethodB()
{
    var customer = new Customer();

    var getAllWidgetsTask = _widgetService.GetAllWidgets();
    var getAllFoosTask = _fooService.GetAllFos();

    Task.WaitAll(new List[] {getAllWidgetsTask, getAllFoosTask});

    customer.Widgets = getAllWidgetsTask.Result;
    customer.Foos = getAllFoosTask.Result;

    return Ok(customer);
}

public async Task MethodA（）
{
var customer=新客户（）；
customer.Widgets=wait_widgetService.GetAllWidgets（）；
customer.Foos=wait_fooService.GetAllFoos（）；
返回Ok（客户）；
}

===============方法B:使用Task.WaitAll=====================

public async Task<IHttpActionResult> MethodA()
{
    var customer = new Customer();

    customer.Widgets = await _widgetService.GetAllWidgets();
    customer.Foos = await _fooService.GetAllFoos();

    return Ok(customer);
}

public async Task<IHttpActionResult> MethodB()
{
    var customer = new Customer();

    var getAllWidgetsTask = _widgetService.GetAllWidgets();
    var getAllFoosTask = _fooService.GetAllFos();

    Task.WaitAll(new List[] {getAllWidgetsTask, getAllFoosTask});

    customer.Widgets = getAllWidgetsTask.Result;
    customer.Foos = getAllFoosTask.Result;

    return Ok(customer);
}

公共异步任务方法b（）
{
var customer=新客户（）；
var getAllWidgetsTask=_widgetService.GetAllWidgets（）；
var getAllFoosTask=_fooService.GetAllFos（）；
Task.WaitAll（新列表[]{getAllWidgetsTask，getAllFoosTask}）；
customer.Widgets=getAllWidgetsTask.Result；
customer.Foos=getAllFoosTask.Result；
返回Ok（客户）；
}

---

============================================

只有第二个选项将并行运行它们。第一个选项将按顺序等待每个调用。

只有第二个选项将并行运行它们。第一个将按顺序等待每个调用。

一旦调用异步方法，它将开始执行。无法确定它是在当前线程上执行（从而同步运行）还是异步运行

public async Task<IHttpActionResult> MethodA()
{
    var customer = new Customer();

    customer.Widgets = await _widgetService.GetAllWidgets();
    customer.Foos = await _fooService.GetAllFoos();

    return Ok(customer);
}

public async Task<IHttpActionResult> MethodB()
{
    var customer = new Customer();

    var getAllWidgetsTask = _widgetService.GetAllWidgets();
    var getAllFoosTask = _fooService.GetAllFos();

    Task.WaitAll(new List[] {getAllWidgetsTask, getAllFoosTask});

    customer.Widgets = getAllWidgetsTask.Result;
    customer.Foos = getAllFoosTask.Result;

    return Ok(customer);
}

因此，在您的第一个示例中，第一个方法将开始工作，但随后您使用wait人工停止代码流。因此，在执行第一个方法之前，不会调用第二个方法

---

第二个示例调用这两个方法，而不使用wait停止流。因此，如果这些方法是异步的，它们可能会并行运行

一旦调用异步方法，它就会开始执行。无法确定它是在当前线程上执行（从而同步运行）还是异步运行

因此，在您的第一个示例中，第一个方法将开始工作，但随后您使用wait人工停止代码流。因此，在执行第一个方法之前，不会调用第二个方法

---

第二个示例调用这两个方法，而不使用wait停止流。因此，如果这些方法是异步的，它们可能会并行运行

第一个选项不会同时执行这两个操作。它将执行第一个并等待其完成，然后才执行第二个

第二个选项将同时执行这两个选项，但将同步等待它们（即在阻塞线程时）

您不应该同时使用这两个选项，因为第一个选项的完成速度比第二个慢，而第二个选项不需要阻塞线程

您应该使用

任务异步等待这两个操作。当所有
：

public async Task<IHttpActionResult> MethodB()
{
    var customer = new Customer();

    var getAllWidgetsTask = _widgetService.GetAllWidgets();
    var getAllFoosTask = _fooService.GetAllFos();

    await Task.WhenAll(getAllWidgetsTask, getAllFoosTask);

    customer.Widgets = await getAllWidgetsTask;
    customer.Foos = await getAllFoosTask;

    return Ok(customer);
}

公共异步任务方法b（）
{
var customer=新客户（）；
var getAllWidgetsTask=_widgetService.GetAllWidgets（）；
var getAllFoosTask=_fooService.GetAllFos（）；
等待任务时（getAllWidgetsTask，getAllFoosTask）；
customer.Widgets=await getAllWidgetsTask；
customer.Foos=等待getAllFoosTask；
返回Ok（客户）；
}

请注意，在
任务之后。当所有的
完成了两个已经完成的任务时，等待它们的任务将立即完成。
第一个选项将不会同时执行这两个操作。它将执行第一个并等待其完成，然后才执行第二个

第二个选项将同时执行这两个选项，但将同步等待它们（即在阻塞线程时）

您不应该同时使用这两个选项，因为第一个选项的完成速度比第二个慢，而第二个选项不需要阻塞线程

您应该使用
任务异步等待这两个操作。当所有
：

public async Task<IHttpActionResult> MethodB()
{
    var customer = new Customer();

    var getAllWidgetsTask = _widgetService.GetAllWidgets();
    var getAllFoosTask = _fooService.GetAllFos();

    await Task.WhenAll(getAllWidgetsTask, getAllFoosTask);

    customer.Widgets = await getAllWidgetsTask;
    customer.Foos = await getAllFoosTask;

    return Ok(customer);
}

公共异步任务方法b（）
{
var customer=新客户（）；
var getAllWidgetsTask=_widgetService.GetAllWidgets（）；
var getAllFoosTask=_fooService.GetAllFos（）；
等待任务时（getAllWidgetsTask，getAllFoosTask）；
customer.Widgets=await getAllWidgetsTask；
customer.Foos=等待getAllFoosTask；
返回Ok（客户）；
}

请注意，在
任务之后。当所有的
任务都完成时，两个任务都已经完成，因此等待它们的任务将立即完成。
简短回答：否

Task.WaitAll
正在阻塞，
wait
在遇到任务时立即返回该任务，并注册函数的剩余部分和continuation

您正在寻找的“批量”等待方法是
Task.whalll
，它实际上创建了一个新的
Task
，在交给函数的所有任务完成时完成

类似这样：
wait Task.WhenAll（{getAllWidgetsTask，getAllFoosTask}）

这就是阻碍问题

此外，您的第一个函数不会同时执行两个函数。要使用
wait
实现此功能，您必须编写如下内容：

var widgetsTask = _widgetService.GetAllWidgets();
var foosTask = _fooService.GetAllWidgets();
customer.Widgets = await widgetsTask;
customer.Foos = await foosTask;

这将使第一个示例的操作与
任务非常相似。whalll
方法。
简短回答：否

Task.WaitAll
正在阻塞，
wait
在遇到任务时立即返回该任务，并注册函数的剩余部分和continuation

您正在寻找的“批量”等待方法是
Task.whalll
，它实际上创建了一个新的
Task
，在交给函数的所有任务完成时完成

类似这样：
wait Task.WhenAll（{getAllWidgetsTask，getAllFoosTask}）

这就是阻碍问题

此外，您的第一个函数不会同时执行两个函数。要使用
wait
实现此功能，您必须编写如下内容：

var widgetsTask = _widgetService.GetAllWidgets();
var foosTask = _fooService.GetAllWidgets();
customer.Widgets = await widgetsTask;
customer.Foos = await foosTask;

这将是第五幕的第一个例子