C#使用Task实现异步方法

一、async和await特性的结构

1. 异步和同步

同步方法：如果一个方法被调用了，等待其执行所有处理后调用方法才继续执行的方法。

异步方法：异步方法能在处理完成之前就回到调用方法。

2.async和await

调用方法：该方法调用异步方法，然后在异步方法（可能在相同的线程，也可能在不同的线程）执行其任务时继续执行。

异步（async）方法：该方法异步执行其工作，被调用时立即回到调用方法。

await表达式：用于异步方法内部，指明需要异步执行的任务。一个异步方法需要至少包含一个await表达式。

二、什么是异步方法

1.异步方法的结构

异步方法在完成其工作之前即返回到调用方法，然后在调用方法继续执行的时候完成其工作。

• 方法头包含async方法修饰符，该修饰符仅标识此方法是一个异步方法。

• 包含至少一个await表达式，表示可以异步完成的任务。

• 必须具备以下三种返回类型中的一种：void、Task、Task<T>。

• 异步方法的参数可以是任意类型，但不能为ref或out。

• 按照约定，异步方法的名称应该为Async为后缀。

• 除了方法以外，Lambda表达式和匿名方法也可以作为异步对象。

2.异步方法三种返回类型理解

1. Task<T> ：如果调用方法要从调用中获取一个T类型的值，异步方法的返回类型就必须是Task<T>。调用方法通过读取Task的Result属性来获取这个T类型的值。

// 使用返回Task<int>对象的异步方法代码示例：    
   static class DoAsyncStuff
   {
       public static async Task<int> CalculateSumAsync(int i1, int i2)
       {
           int sum = await Task.Run(() => GetSum(i1, i2));
           return sum;//注意返回的是一个int类型
       }

private static int GetSum(int i1, int i2) { return i1 + i2; }

}
   internal class Program
   {
       static void Main(string[] args)
       {
           Task<int> task = DoAsyncStuff.CalculateSumAsync(1, 2);
           //处理其他事情...
           Console.WriteLine("Value:{0}",task.Result);//调用方法通过Result获取这个int类型的值

}
   }

2.Task ： 如果调用方法不需要从异步方法中返回某个值，但需要检查异步方法的状态，那么异步方法可以返回一个Task类型的对象，这时即使异步方法中出现了return语句，也不会返回任何东西。

//使用Task不返回类型的异步方法代码示例：
   static class DoAsyncStuff
   {
       public static async Task CalculateSumAsync(int i1, int i2)
       {
           int sum = await Task.Run(() => GetSum(i1, i2));
           Console.WriteLine("Value:{0}",sum);
       }

private static int GetSum(int i1, int i2) { return i1 + i2; }

}
   internal class Program
   {
       static void Main(string[] args)
       {
           Task task = DoAsyncStuff.CalculateSumAsync(1, 2);
           //处理其他事情...
           task.Wait();
           Console.WriteLine("异步方法结束");
       }
   }

3. void ：如果调用方法仅仅想执行异步方法，而不需要与它进行进一步交互时【称为&ldquo;调用并忘记&rdquo;】，异步方法可以返回void类型。

//使用“调用并忘记”的异步方法的代码示例：
   static class DoAsyncStuff
   {
       public static async void CalculateSumAsync(int i1, int i2)
       {
           int sum = await Task.Run(() => GetSum(i1, i2));
           Console.WriteLine("Value:{0}",sum);
       }

private static int GetSum(int i1, int i2) { return i1 + i2; }

}
   internal class Program
   {
       static void Main(string[] args)
       {
           DoAsyncStuff.CalculateSumAsync(1, 2);
           //处理其他事情...
           Thread.Sleep(200);
           Console.WriteLine("Program Exiting");
       }
   }

3.异步方法的控制流

1. 异步方法的结构包含三个不同的区域：

 控制流阐述：

• 调用异步方法后，知道遇到第一个await表达式之前都是同步的。

• 遇到await表达式之后，异步方法将控制返回到调用方法。如果方法的返回类型为Task或Task<T>类型，将创建一个Task对象，表示需异步完成的任务和后续，然后将Task返回到调用方法。

• 到目前为止，已经出现两个控制流，异步方法内的和调用方法内的。异步方法的代码完成以下工作：

• 异步执行await表达式的空闲任务。

• 当await表达式完成时，执行后续部分。如果后续还有await表达式，将重复此步骤：异步执行await表达式，然后执行后续部分。

• 当后续部分遇到return语句或到达方法末尾时：

• 如果方法返回类型为void，控制流将退出。

• 如果方法返回类型为Task，后续部分设置Task的属性并退出。

• 如果方法返回类型为Task<T>,后续部分还将设置Task的Result属性。

• 同时调用方法中的代码继续其进程，从异步方法获取Task对象。当需要其实际值时，就引用Task对象的Result属性，届时，如果异步方法设置了该属性，调用方法就能调用其值并继续，否则将暂停等待该属性被设置，然后再继续执行。

 需要注意的是：异步方法的return语句并没有真正返回一个值，它只是退出了，异步方法中的返回类型始终是方法头中声明的返回类型。

三、await表达式

await表达式指定了一个异步执行的任务。这个任务可能是一个Task类型的对象，也可能不是，默认情况下这个任务在当前线程异步运行。

我们可能需要编写自己的方法作为await表达式的任务。最简单的方式是在你的方法中使用Task.Run创建一个Task。（关于Task.Run即在不同的线程上运行你的方法）Task.Run方法有8个重载 ，如下图所示：

以Func<int> 委托作为参数的代码示例：

class MyClass
   {
       public int Get10()
       {
           return 10;
       }

public async Task DoWorkAsync()
       {
           //方式1：使用Get10创建名为ten的Func<int>委托，将该委托传入Task.Run方法
           Func<int> ten = new Func<int>(Get10);
           int a = await Task.Run(ten);

//方式2：直接在Task.Run中创建委托，传入Get10方法
           int b = await Task.Run(new Func<int>(Get10));

//方式3：使用与Func<T>兼容的Lambda表达式，Lambda表达式将隐式转换为该委托
           int c = await Task.Run(() => { return 10; });

Console.WriteLine("{0},{1},{2}",a,b,c);
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           Task task = new MyClass().DoWorkAsync();
           task.Wait();
       }
   }

从Task.Run的重载中可以发现，可以作为Run中第一个参数的委托有四种：

使用四种委托作为参数的Run方法代码示例：

class MyClass
   {
       public static async Task DoWorkAsync()
       {
           await Task.Run(() => Console.WriteLine(5.ToString()));//Aciton,无参无返

Console.WriteLine((await Task.Run(() => 6)).ToString());//TResult Func()，无参有返，返回TResult类型对象

await Task.Run(() => Task.Run(() => Console.WriteLine(7.ToString())));//Task Func()，无参有返，返回简单Task对象

Console.WriteLine((await Task.Run(() => Task.Run(() => 8))).ToString());//Task<TResult> Func()，无参有返，返回Task<T>对象
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           Task task = MyClass.DoWorkAsync();
           task.Wait();
       }
   }

假如我们需要一个接受参数的方法，但是无法匹配上述的四种委托（接受没有参数的方法的委托），我们可以创建一个Lambda表达式，其唯一行为就是运行我们的接受参数的方法，来满足Run方法所能接受的委托形式。代码示例如下：

class MyClass
   {
       //需要使用异步的方法
       public static int GetSum(int a, int b) { return a + b; }

public static async Task DoWorkAsync(int a,int b)
       {
           int result = await Task.Run(() => GetSum(a, b));//创建一个满足Func<TResult>委托形式的Lambda表达式
           Console.WriteLine(result);
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           Task task = MyClass.DoWorkAsync(6,7);
           task.Wait();
       }
   }

四、取消一个异步操作

一些.NET异步方法允许你请求终止执行，我们可以在自己的异步方法中加入这个特性。有两个类：CancellationToken和CancellationTokenSource是专门为了取消异步操作设计的。

1. CancellationToken对象包含了一个任务是否应被取消的消息。拥有CancellationToken对象的任务需要定期检查其令牌（token）的状态，如果CancellationToken对象中的IsCancellationRequested属性为true，任务需停止其操作并返回。CancellationToken是不可逆的，也就是一旦IsCancellationRequested设置为true就不能更改了。

2.  CancellationTokenSource对象创建可分配给不同任务的CancellationToken对象。任何持有CancellationTokenSource的对象都可以调用其Cancel方法，这会将CancellationToken对象中的IsCancellationRequested设置为true。

3. 使用这两个取消类的代码：

class MyClass
   {
       public async Task RunAsync(CancellationToken ct)
       {
           if (ct.IsCancellationRequested)
               return;
           await Task.Run(()=>CycleMethod(ct));
       }

void CycleMethod(CancellationToken ct)
       {
           Console.WriteLine("开始CycleMethod方法");

const int max = 5;

for (int i = 0; i < max; i++)
           {
               if (ct.IsCancellationRequested)
                   return;
               Thread.Sleep(1000);
               Console.WriteLine("完成：{0}/{1}",i+1,max);
           }
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           CancellationTokenSource cts = new CancellationTokenSource();
           CancellationToken ct = cts.Token;

MyClass mc = new MyClass();

Task t = mc.RunAsync(ct);

/*
               取消异步操作的过程是协同的：
                   即调用CancellationTokenSource的Cancel时，它本身并不会执行取消操作
                   而是会将CancellationToken的IsCancellationRequested属性设置为true
                   包含CancellationToken的代码负责检查该属性，并判断是否需要停止执行并返回
            */
           //Thread.Sleep(3000);
           //cts.Cancel();//解除注释将产生取消异步的操作

t.Wait();
           Console.WriteLine("是否取消了异步方法：{0}", ct.IsCancellationRequested);

}
   }

五、异常处理的await表达式

就使用try...catch...正常处理异常就行。

class MyClass
   {
       public static async Task BadAsync()
       {
           try
           {
               await Task.Run(() => { throw new Exception(); });
           }catch (Exception ex)
           {
               Console.WriteLine("异步中抛出异常...");
           }
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           Task task = MyClass.BadAsync();
           task.Wait();
           Console.WriteLine("Task Status：{0}",task.Status);//Task Status：RanToCompletion，因为Task没有被取消
           Console.WriteLine("Task IsFaulted：{0}",task.IsFaulted);//Task IsFaulted：False，因为没有未处理的异常

}
   }

六、在调用方法中同步地等待任务

1. Wait

Task的Wait方法可以让调用方法等待异步方法完成，在Wait方法处，流程是阻塞的。

class MyClass
   {
       public void PrintA()
       {
           const int max = 10;
           for (int i = 0; i < max; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
           }
       }
       public async Task ForWaitAsync()
       {
           await Task.Run(new Action(PrintA));
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           MyClass mc = new MyClass();
           Task t = mc.ForWaitAsync();

Thread.Sleep(6000);//主线程休眠6秒

//等待任务完成,使用此方法可以让主方法等待异步方法完成，否则主方法休眠六秒结束时异步方法也将直接结束
           t.Wait();
       }
   }

2. WaitAll和WaitAny

Wait是等待单一任务完成，我们也可以使用WaitAll和WaitAny等待多个任务。（这两个方法是同步方法，知道等待条件满足后再继续执行，不然流程会阻塞在那里）

class MyClass
   {
       public void PrintA()
       {
           const int max = 10;
           for (int i = 0; i < max; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
           }
           Console.WriteLine("A任务全部完成！");
       }

public void PrintB()
       {
           const int max = 5;
           for (int i = 0; i < max; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("B任务完成：{0}/{1}", i + 1, max);
           }
           Console.WriteLine("B任务全部完成！");
       }

public async Task AForWaitAsync()
       {
           await Task.Run(new Action(PrintA));
       }

public async Task BForWaitAsync()
       {
           await Task.Run(new Action(PrintB));
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           MyClass mc = new MyClass();
           Task a = mc.AForWaitAsync();
           Task b = mc.BForWaitAsync();

Task[] task = new Task[] { a, b };//存放Task的数组

Thread.Sleep(8000);//调用方法休眠8秒

//Task.WaitAll(task);//等待所有任务完成
           Task.WaitAny(task);//等待任意一个任务完成后将不再阻塞

}
   }

WaitAll和WaitAny分别还包含四个重载：

七、在异步方法中异步地等待任务 

有时在异步方法中，你会希望用await表达式来等待Task。这时异步方法会返回到调用方法，但该异步方法会等待一个或所有任务完成。可以通过Task.WhenAll或Task.WhenAny方法来实现。这两个方法称为组合子。

class MyClass
   {
       public void PrintA()
       {
           const int max = 10;
           for (int i = 0; i < max; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("A任务完成：{0}/{1}", i + 1, max);
           }
       }

public void PrintB()
       {
           const int max = 5;
           for (int i = 0; i < max; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("B任务完成：{0}/{1}", i + 1, max);
           }
       }

public async Task AAsync()
       {
           await Task.Run(new Action(PrintA));
       }

public async Task BAsync()
       {
           await Task.Run(new Action(PrintB));
       }

public async Task ForWhenAsync()
       {
           Task a = AAsync();
           Task b = BAsync();

Task[] tasks = { a, b };//Task数组

//await Task.WhenAll(tasks);//在异步中等待所有任务
           await Task.WhenAny(tasks);//在异步中等待任意一个任务

//此异步方法中的流程会阻塞在Task.WhenAny(tasks)中，直到某个条件满足才会到达这里
           Console.WriteLine("现在任务A是否完成：{0}",a.IsCompleted?"Yes":"No");
           Console.WriteLine("现在任务B是否完成：{0}",b.IsCompleted?"Yes":"No");
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           const int max = 12;

MyClass mc = new MyClass();
           mc.ForWhenAsync();

for (int i = 0;i < max ; i++)
           {
               Thread.Sleep(1000);
               Console.WriteLine("Main任务完成：{0}/{1}", i + 1, max);
           }

}
   }

八、Task.Delay方法

Task.Delay方法创建一个对象，该对象将暂停其在线程中的处理，并在一定时间之后完成。和Thread.Sleep阻塞线程不同的是，Task.Delay方法不会阻塞线程，线程可以继续处理其他工作。

class Simple
   {
       Stopwatch sw = new Stopwatch();

public void DoRun()
       {
           Console.WriteLine("调用之前");
           ShowDelayAsync();
           Console.WriteLine("调用之后");
       }

private async void ShowDelayAsync()
       {
           sw.Start();
           Console.WriteLine("Delay 执行之前：{0}",sw.ElapsedMilliseconds);
           await Task.Delay(1000);//创建了一个Task对象，该对象将暂停其在线程中的处理，所以在打印下一句话之前，控制回到了调用方法打印调用方法中的"调用之后"
           Console.WriteLine("Delay 执行之后：{0}", sw.ElapsedMilliseconds);
       }
   }
   internal class Program
   {
       static void Main(string[] args)
       {
           Simple simple = new Simple();
           simple.DoRun();
           Console.Read();

}
   }

来源：https://blog.csdn.net/weixin_66598341/article/details/129981828