C#异步：编写异步函数

合集 - C#8.0核心技术指南[学习笔记](21)

1.C#集合：枚举IEnumerable2022-06-292.C#集合：ICollection和IList接口2022-08-263.C#集合：字典2022-08-304.C#集合：List、Queue、Stack和Set2022-08-295.C#集合：Array类2022-08-266.C#线程2022-09-137.C#线程：任务Task2022-09-138.C#线程：本地存储2022-09-069.C#异步：等待2022-06-25

10.C#异步：编写异步函数2022-06-26

11.C#异步：Task.WhenAny和Task.WhenAll2022-06-2812.C#异步：异步流2022-06-2813.C#线程：排它锁2022-08-3014.C#线程：非排他锁2022-08-3115.C#并行编程：简要2022-09-0116.C#并行编程：PLINQ2022-09-0217.C#.Net 定时器2022-09-0118.C#线程：使用事件等待句柄发送信号2022-09-0119.C#并行编程：并发集合2022-09-0820.C#并行编程：任务并行2022-09-0721.C#并行编程：Parallel类2022-09-05

收起

要编写异步函数，可将返回类型void改为Task。这样方法本身就能进行异步调用，并且是可等待的。

async Task PrintAnswerToLife()
{
	await Task.Delay (5000);
	int answer = 21 * 2;
	Console.WriteLine (answer);  
}

方法体内并不需要返回一个任务。编译器会负责生成Task，并在方法完成之前触发Task。这样就很容易创建异步调用链。

async Task Go()
{
	await PrintAnswerToLife();
	Console.WriteLine ("Done");
}

由于Go方法的返回值为Task，因此它本身就是可等待的。

编译器会展开异步函数，将任务对象返回，并使用TaskCompletionSource创建一个新的任务对象。
下面将PrintAnswerToLife方法展开为如下等价实现：

Task PrintAnswerToLife()
{
    var tcs = new TaskCompletionSource<object>();
    var awaiter = Task.Delay(5000).GetAwaiter();
    awaiter.OnCompleted(() =>
    {
        try
        {
            awaiter.GetResult();
            int answer = 21 * 2;
            Console.WriteLine(answer);
            tcs.SetResult(null);
        }
        catch(Exception ex)
        {
            tcs.SetException(ex);
        }
    });
    return tcs.Task;
}

因此，当返回任务的异步函数结束时，执行过程都会通过延续返回等待它的程序。

返回Task

异步函数中若方法体返回TResult，则函数的返回值为Task。

async Task<int> GetAnswerToLife()
{
	await Task.Delay (5000);
	int answer = 21 * 2;
	return answer;
}

在实现内部，这段代码在激活TaskCompletionSource时传递answer值而不是null。

使用C#异步函数的基本原则

1. 首先以同步方式实现方法。
2. 其次，将同步方法调用改为异步方法调用，并使用await。
3. 除“最顶层级”方法外，将异步方法返回类型修改为Task或Task，使其成为可等待的方法。

由于编译器能为异步编程函数创建任务，因此，除非要进行I/O密级并发底层编程，一般情况下无需显式实例化TaskCompletionSource类型。对于计算密集型的并发方法，则可以使用Task.Run创建任务。

执行异步调用图

为了确切理解异步调用图的执行过程，将代码重新排列：

async Task Go()
{
    var task = PrintAnswerToLife();
    await task;
    Console.WriteLine("Done");
}
 
async Task PrintAnswerToLife()
{
    var task = GetAnswerToLife();
    int answer = await task;
    Console.WriteLine(answer);
}
 
async Task<int> GetAnswerToLife()
{
    var task = Task.Delay(5000);
    await task;
    int answer = 21 * 2;
    return answer;
}

上述这些过程都是在调用Go的线程上同步执行的。这就是主要的同步执行阶段。
5秒后，Delay上的延续被触发，执行点返回到GetAnswerToLife并在线程池线程上执行。随后，GetAnswerToLife的其他语句将执行，而Task也将得到结果42，并结束执行。之后，执行点执行PrintAnswerToLife的延续，即PrintAnswerToLife剩余代码。这个执行过程将一直持续直至Go中的任务执行完毕。

由于和同步调用采用了同一种模式，因此整个执行流和同步调用图是完全匹配的。
每一个异步方法调用后都会await，这样就形成了一个无并发的调用图。每个await表达式都在执行过程中形成了一个“缺口”，而之后的程序都可以在缺口处恢复执行。