为什么分配任务然后等待它允许并行运行

Question

我一直在玩 async 并且遇到了一些我以前没有注意到的行为，如果这是重复的，请告诉我，但是我的 google-fu 失败了，主要是因为我想不出体面的搜索条件：

给定一个简单的异步方法，它执行一些参数化工作：

async Task<String> Foo(int i)
{
    await Task.Delay(i);
    return i.ToString();
}

以及在不同上下文中调用它并捆绑结果的调用方法：

async Task<Object> Bar()
{
    var one =    Foo(3000);
    var two =    Foo(5000);
    var three =  Foo(3000);

    var x =
        new
        {
            One =   await one,
            Two =   await two,
            Three = await three,
        };      
        
    return x;
}

这在 5 秒内完成（在 Linqpad6、.NET Core 3.1 中）。所以我假设每个任务同时运行。

但是，如果我将其更改为在开始时执行等待，则它会在 11 秒内完成。所以我假设每个任务都是按顺序运行的。

async Task<Object> Bar()
{
    var one =   await Foo(3000);
    var two =   await Foo(5000);
    var three = await Foo(3000);

    var x =
        new
        {
            One =   one,
            Two =   two,
            Three = three,
        };
        
    return x;
}

我的问题是，分配任务，然后等待它，而不是等待它允许它们并行完成是什么意思？

Answer 1

在线查看评论

async Task<Object> Bar()
{
    var one =    Foo(3000); // <-- It can Start
    var two =    Foo(5000); // <-- It can Start
    var three =  Foo(3000); // <-- It can Start

    var x =
        new
        {
            One =   await one,  // <-- you are waiting for it to finish
            Two =   await two,  // <-- you are waiting for it to finish
            Three = await three,// <-- you are waiting for it to finish
        };      
        
    return x;
}

async Task<Object> Bar()
{
    var one =   await Foo(3000); // <-- you are waiting for it to finish
    var two =   await Foo(5000); // <-- you are waiting for it to finish
    var three = await Foo(3000); // <-- you are waiting for it to finish

    var x =
        new
        {
            One =   one,
            Two =   two,
            Three = three,
        };
        
    return x;
}