4. 实现流程详解

初始化状态机

在 CalculateAsync 方法中，创建状态机实例 d__0 。

d__0 stateMachine = new d__0();
stateMachine.<>4__this = this;
stateMachine.<>t__builder = AsyncTaskMethodBuilder.Create();
stateMachine.<>1__state = -1;

• <>4__this ：指向当前实例，即 Example 类的实例。
• <>t__builder ：创建 AsyncTaskMethodBuilder 实例，用于管理任务的生命周期。
• <>1__state ：初始化状态为 -1 ，表示方法尚未开始执行。

开始执行

调用 Start 方法开始执行异步方法。 Start 方法会调用状态机的 MoveNext 方法。

stateMachine.<>t__builder.Start(ref stateMachine);

执行方法体

在 MoveNext 方法中，根据当前状态 <>1__state 执行相应的代码。

private void MoveNext()
{
    int num = <>1__state;
    try
    {
        TaskAwaiter awaiter;
        switch (num)
        {
            // 处理不同的状态
        }
    }
    catch (Exception exception)
    {
        <>1__state = -2;
        <>t__builder.SetException(exception);
    }
}

遇到 await

遇到第一个 await 关键字时，调用 Task.Run(() => 10).GetAwaiter() 获取 Awaiter 对象。

awaiter = Task.Run(() => 10).GetAwaiter();

• 检查 awaiter.IsCompleted ，如果任务已经完成，直接调用 awaiter.GetResult() 获取结果。
• 如果任务未完成，记录当前状态 <>1__state ，保存 awaiter 对象，并调用 <>t__builder.AwaitUnsafeOnCompleted 注册回调。

if (!awaiter.IsCompleted)
{
    num = (<>1__state = 0);
    <>u__1 = awaiter;
    <>t__builder.AwaitUnsafeOnCompleted(ref awaiter, ref this);
    return;
}

注册回调

AwaitUnsafeOnCompleted 方法会注册一个回调，当任务完成时，回调会被触发。

public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine)
    where TAwaiter : ICriticalNotifyCompletion
    where TStateMachine : IAsyncStateMachine
{
    awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
}

• awaiter.UnsafeOnCompleted 方法注册一个回调函数，该回调函数会在任务完成时被触发。
• stateMachine.MoveNext 是一个委托，指向状态机的 MoveNext 方法。

任务完成

当任务完成时，回调会被触发，重新调用 MoveNext 方法，恢复异步方法的执行。

public void OnCompleted(Action continuation)
{
    task.ContinueWith(_ => continuation(), TaskScheduler.Default);
}

继续执行

从上次暂停的地方继续执行方法体。

• 遇到第二个 await 关键字时，重复上述步骤。

方法完成

当所有异步操作完成并计算出结果后，设置状态 <>1__state 为 -2 ，表示方法已经完成。

• 调用 <>t__builder.SetResult 设置任务的结果。
• 如果在执行过程中抛出异常，捕获异常并调用 <>t__builder.SetException 设置任务的异常。

catch (Exception exception)
{
    <>1__state = -2;
    <>t__builder.SetException(exception);
}

5. 深入理解 AsyncTaskMethodBuilder

AsyncTaskMethodBuilder 是一个辅助类，用于构建和管理异步方法的任务。它提供了以下方法：

• Create ：创建一个新的 AsyncTaskMethodBuilder 实例。
• Start ：开始执行异步方法，调用状态机的 MoveNext 方法。
• AwaitUnsafeOnCompleted ：注册回调函数，当任务完成时触发回调。
• SetResult ：设置任务的结果。
• SetException ：设置任务的异常。

AsyncTaskMethodBuilder 的内部实现

AsyncTaskMethodBuilder 内部维护了一个 Task 对象，用于表示异步操作的结果。当异步方法完成时， SetResult 方法会设置任务的结果， SetException 方法会设置任务的异常。

public struct AsyncTaskMethodBuilder
{
    private Task task;

    public static AsyncTaskMethodBuilder Create()
    {
        return new AsyncTaskMethodBuilder(new Task());
    }

    private AsyncTaskMethodBuilder(Task task)
    {
        this.task = task;
    }

    public void Start(ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine
    {
        stateMachine.MoveNext();
    }

    public void AwaitOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        awaiter.OnCompleted(stateMachine.MoveNext);
    }

    public void AwaitUnsafeOnCompleted(ref TAwaiter awaiter, ref TStateMachine stateMachine)
        where TAwaiter : ICriticalNotifyCompletion
        where TStateMachine : IAsyncStateMachine
    {
        awaiter.UnsafeOnCompleted(stateMachine.MoveNext);
    }

    public void SetResult(TResult result)
    {
        task.SetResult(result);
    }

    public void SetException(Exception exception)
    {
        task.SetException(exception);
    }

    public Task Task => task;
}

6. 异步方法的生命周期

异步方法的生命周期可以分为以下几个阶段：

1. 初始化 ：创建状态机实例，初始化状态和任务构建器。
2. 开始执行 ：调用 Start 方法开始执行异步方法。
3. 执行方法体 ：在 MoveNext 方法中，根据当前状态执行相应的代码。
4. 遇到 await ：检查任务是否完成，如果未完成则注册回调并暂停方法执行。
5. 任务完成 ：回调被触发，重新调用 MoveNext 方法，恢复异步方法的执行。
6. 方法完成 ：所有异步操作完成，设置任务的结果或异常。

7. 异步方法的优势

使用 async 和 await 编写的异步方法有以下优势：

• 提高响应性 ：异步方法不会阻塞主线程，应用程序可以继续响应用户的输入和其他事件。
• 提高性能 ：异步方法可以并发执行多个任务，充分利用系统资源。
• 简化代码 ：异步方法的代码结构类似于同步方法，易于理解和维护。

8. 异步方法的注意事项

尽管 async 和 await 提供了许多优势，但在使用时也需要注意以下几点：

• 避免 async void ： async void 方法主要用于事件处理程序，其他情况下应避免使用，因为它无法被等待，并且异常处理较为困难。
• 异常处理 ：异步方法中的异常会被包装在 AggregateException 中，需要特殊处理。
• 资源管理 ：异步方法中使用 using 语句时，需要注意 Dispose 方法的调用时机。

9. 完整的流程图

为了更好地理解这个过程，可以用流程图来展示：

总结

通过上述详细的解释和示例代码，我们可以总结出以下几点：

1. 异步方法的基本概念 ： async 和 await 关键字用于编写异步代码。
2. 状态机的生成 ：编译器为每个异步方法生成一个状态机，包含所有局部变量和状态信息。
3. MoveNext 方法的执行 ： MoveNext 方法是状态机的核心，负责管理和执行异步操作。
4. 回调函数的注册和触发 ：
   • 当遇到 await 关键字时，编译器会生成代码来检查任务是否已经完成。
   • 如果任务未完成，注册回调并暂停方法执行。
   • 当任务完成时，回调函数会被触发，重新调用状态机的 MoveNext 方法，从而恢复异步方法的执行。
5. AwaitUnsafeOnCompleted 方法的作用 ：在任务完成时注册一个回调函数，回调函数会在任务完成后被触发，从而恢复异步方法的执行。

希望这些解释能帮助你更好地理解 await 实现原理。如果你还有任何疑问，请随时提问！
详情请看： https://www.cnblogs.com/Bob-luo/p/18518463

希望这篇文章对你有所帮助！如果你有任何进一步的问题或需要更多的细节，请告诉我。