目录
一、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 ：如果调用方法仅仅想执行异步方法，而不需要与它进行进一步交互时【称为“调用并忘记”】，异步方法可以返回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();
}
}
1205
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
