在for循环中使用await

在循环中调用多个函数，都使用await的话，和同步效果一样。

 public static async void fun1()
        { 
string str = "";
            Console.WriteLine("同步开始");
            for (int i = 0; i < 10; i++)
            {
              str+= await fun2(i)+"\n";
            }
            Console.WriteLine("同步结束");
}
 public static async Task<int> fun2(int i)
        {
           await Task.Delay(1000);
            Console.WriteLine(i+"--fun2--"+DateTime.Now.ToString("HH:mm:ss.fff"));
            return Convert.ToInt32(DateTime.Now.ToString("fff"));
        }

结果如下：

 不是用await关键字可以事先异步调用多个函数，但是并不清楚每个函数执行结果如何

  public static async void fun1()
        {
            #region 循环内 调用函数 异步
            Console.WriteLine("异步调用开始，不考虑函数执行结果");
            for (int i = 0; i < 10; i++)
            {
                fun2(i);//异步方式，不接收返回值
            }
            Console.WriteLine("异步调用结束，不考虑函数执行结果");

            #endregion
        }
      
        public static async Task<int> fun2(int i)
        {
           await Task.Delay(1000);
            Console.WriteLine(i+"--fun2--"+DateTime.Now.ToString("HH:mm:ss.fff"));
            return Convert.ToInt32(DateTime.Now.ToString("fff"));
        }

结果如下：

 当需要清楚每个函数执行结果时，需要使用到Tuple（元组）

public static async void fun1()
        {
            Console.WriteLine("异步调用开始，需要等待每个函数的结果");
            var list = new Listint,bool>>>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(write(i));
            }
            foreach (var item in await Task.WhenAll(list))
            {
                Console.WriteLine(item.Item1+","+item.Item2);
            }
            Console.WriteLine("异步调用结束，需要等待每个函数的结果");
        }
        public static async Taskint,bool>> write(int i)
        {

            //Thread.Sleep(1000);
            await Task.Delay(1000);
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            return Tuple.Create(i,true);
        }

结果如下：

 元组Tuple<>可定义多个类型的变量，用于接收返回值；以上代码中定义了，使用int标识第几个函数，bool标识执行状态。

将for循环内的函数，添加到var list =new List>>()中。

使用await Task.WhenAll(list) 进行调用。返回内容包含 int 和bool 两个值，使用Item1 和Item2 调用。

被调用的函数需要将返回类型改为 Task>；执行完毕后，return Trple.Create(i,true);//这里按实际返回内容

整体是这个意思，我还没弄懂原理；

完整代码如下：

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            fun1();
            Console.WriteLine("主"+DateTime.Now.ToString("HH:mm:ss.fff")+"\n");
            Console.ReadLine();
        }
        public static async void fun1()
        {
            #region 循环内 调用函数  同步
            string str = "";
            Console.WriteLine("同步开始\n");
            for (int i = 0; i < 10; i++)
            {
              str+= await fun2(i)+"\n";
            }
            Console.WriteLine("同步结束\n");
            #endregion 结束
            #region 循环内 调用函数 异步
            Console.WriteLine("异步调用开始，不考虑函数执行结果\n");
            for (int i = 0; i < 10; i++)
            {
                fun2(i);//异步方式，不接收返回值
            }
            Console.WriteLine("异步调用结束，不考虑函数执行结果\n");

            Console.WriteLine("异步调用开始，需要等待每个函数的结果\n");
            var list = new Listint,bool>>>();
            for (int i = 0; i < 10; i++)
            {
                list.Add(write(i));
            }
            foreach (var item in await Task.WhenAll(list))
            {
                Console.WriteLine(item.Item1+","+item.Item2);
            }
            Console.WriteLine("异步调用结束，需要等待每个函数的结果\n");
            #endregion
        }
        public static async Taskint,bool>> write(int i)
        {

            //Thread.Sleep(1000);
            await Task.Delay(1000);
            Console.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff"));
            return Tuple.Create(i,true);
        }
        public static async Task<int> fun2(int i)
        {
           await Task.Delay(1000);
            Console.WriteLine(i+"--fun2--"+DateTime.Now.ToString("HH:mm:ss.fff"));
            return Convert.ToInt32(DateTime.Now.ToString("fff"));
        }
    }
}

结果如下：