C# 控制台应用程序中正确的异步循环

我知道异步I/O不会带来并行性，但我认为当应用程序等待异步操作时，它可以继续做其他事情

考虑下面的代码，我希望循环在等待等待（I）时继续，但显然我错了，每个迭代都被阻塞了。在这里实现并发的正确方法是什么

using System;
using System.Threading.Tasks;

namespace asynctest
{
    class Program
    {
        static void Main(string[] args)
        {
            Do().GetAwaiter().GetResult();
        }

        public static async Task Do()
        {   
            for(int i=0;i<10;i++)
            {
                await Wait(i);
            }
        }

        public static async Task Wait(int i)
        {
            await Task.Delay(10000);
        }
    }
}

使用系统；
使用System.Threading.Tasks；
命名空间异步测试
{
班级计划
{
静态void Main（字符串[]参数）
{
Do（）.GetAwaiter（）.GetResult（）；
}
公共静态异步任务Do（）
{   
对于（inti=0；i
publicstaticasynctask Do（））
{
var任务=新任务[10]；
对于（int i=0；i<10；i++）
{
任务[i]=等待（i）；
}
等待任务。何时（任务）；
}
公共静态异步任务Do（）
{
var任务=新任务[10]；
对于（int i=0；i<10；i++）
{
任务[i]=等待（i）；
}
等待任务。何时（任务）；
}
您应该使用
WhenAll（）
组合任务结果，这样您的任务将并行运行：

namespace asynctest
{
    class Program
    {
        static void Main(string[] args)
        {
            Do().GetAwaiter().GetResult();
        }

        public static async Task Do()
        {   
            for(int i=0;i<10;i++)
            {

              var task1 = Wait(5000);
              var task2 = Wait(3000);   
              int[] result = await Task.WhenAll(task1, task2);
              Console.WriteLine("waited for a total of " + result.Sum() + " ms");          
            }
        }

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

namespace异步测试
{
班级计划
{
静态void Main（字符串[]参数）
{
Do（）.GetAwaiter（）.GetResult（）；
}
公共静态异步任务Do（）
{   
对于（int i=0；i您应该使用
WhenAll（）
组合任务结果，这样您的任务将并行运行：

namespace asynctest
{
    class Program
    {
        static void Main(string[] args)
        {
            Do().GetAwaiter().GetResult();
        }

        public static async Task Do()
        {   
            for(int i=0;i<10;i++)
            {

              var task1 = Wait(5000);
              var task2 = Wait(3000);   
              int[] result = await Task.WhenAll(task1, task2);
              Console.WriteLine("waited for a total of " + result.Sum() + " ms");          
            }
        }

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

namespace异步测试
{
班级计划
{
静态void Main（字符串[]参数）
{
Do（）.GetAwaiter（）.GetResult（）；
}
公共静态异步任务Do（）
{   
对于（int i=0；这是
await
所做的。它暂停循环以使并发代码按顺序运行。await通常会阻止操作以等待其他操作完成。但在这里，它似乎阻止了每个迭代，因为每个迭代占用的时间几乎相同。如果您愿意，您可以理解其中的差异将不同类型的任务放入任务数组中，并使用wait运算符处理数组索引这就是
wait
所做的。它暂停循环以使并发代码按顺序运行。wait通常会阻止操作以等待其他操作完成。但在这里，它似乎阻止了每个迭代，因为每个迭代都需要alm如果将不同类型的任务放在任务数组中，并使用wait运算符处理数组索引，则可以理解其中的差异