15.5.2 【Task实现细节】骨架方法的结构

　　尽管骨架方法中的代码非常简单，但它暗示了状态机的职责。代码清单15-11生成的骨架方法如下所示：

         [DebuggerStepThrough]

         [AsyncStateMachine(typeof(DemoStateMachine))]

         static Task<int> SumCharactersAsync(IEnumerable<char> text)

         {

             var machine = new DemoStateMachine();

             machine.text = text;

             machine.builder = AsyncTaskMethodBuilder<int>.Create();

             machine.state = -;

             machine.builder.Start(ref machine);

             return machine.builder.Task;

         }

　　AsyncStateMachineAttribute 类型是为 async 引入的新特性（attribute）之一。它是为工具而设计的，你自己并不会有机会消费这个特性，并且也不应该在自己的方法上应用这个特性。
我们已经在这个状态机上看到了三个字段。
 一个是参数（ text ）。显然有多少个参数就会有多少个字段。
 一个是 AsyncTaskMethodBuilder<int> 。该结构负责将状态机和骨架方法联系在一起。对于仅返回 Task 的方法，存在对应的非泛型类。对于返回 void 的方法，可以使用AsnycVoidMethodBuilder 结构。
 一个是 state ，值从 -1 开始。初始值永远为 -1 ，稍后我们会介绍其他值的含义。

　　由于状态机是一个结构（struct）， AsyncTaskMethodBuilder<int> 也是一个结构，因此我们还没有执行任何堆分配。当然，完全可以让执行的不同调用在堆上进行分配，但有必要指出的是，代码在尽可能地避免这么做。异步的本质意味着，如果哪个 await 表达式需要真正的等待，你会需要很多这种值（在堆上），但代码保证了它们只会在需要的时候进行装箱。所有这些都属于实现细节，就像堆和栈属于实现细节一样，但为了让 async 能够适用于尽可能多的场景，微软的相关团队紧密合作，将分配降低到了绝对最小值。

　　对 machine.builder.Start(ref machine) 的调用非常有意思。这里使用了按引用传递，以避免创建状态机的复本（以及builder的复本），这是出于性能和正确性两方面的考虑。编译器非常愿意将状态机和builder视为类，因此 ref 可以在代码中自由地使用。为了使用接口，不同的方法将builder（或awaiter）作为参数，使用泛型类型参数，并限定其实现某个接口（如对于状态机来说就是 IAsyncStateMachine ）。这样在调用接口的成员时，就不需要任何装箱了。方法的行为描述起来非常简单——它让状态机同步地执行第一个步骤，并在方法完成时或到达需等待的异步操作点时得以返回。

　　第一个步骤完成后，骨架方法将返回builder中的任务。状态机在结束时，会使用builder来设置结果或异常。

     class DecompilationSampleDecompiled

     {

         static void Main()

         {

             Task<int> task = SumCharactersAsync("test");

             Console.WriteLine(task.Result);

         }

         [DebuggerStepThrough]

         [AsyncStateMachine(typeof(DemoStateMachine))]

         static Task<int> SumCharactersAsync(IEnumerable<char> text)

         {

             var machine = new DemoStateMachine();

             machine.text = text;

             machine.builder = AsyncTaskMethodBuilder<int>.Create();

             machine.state = -;

             machine.builder.Start(ref machine);

             return machine.builder.Task;

         }

         [CompilerGenerated]

         private struct DemoStateMachine : IAsyncStateMachine

         {

             // Fields for parameters

             public IEnumerable<char> text;

             // Fields for local variables

             public IEnumerator<char> iterator;

             public char ch;

             public int total;

             public int unicode;

             // Fields for awaiters

             private TaskAwaiter taskAwaiter;

             private YieldAwaitable.YieldAwaiter yieldAwaiter;

             // Common infrastructure

             public int state;

             public AsyncTaskMethodBuilder<int> builder;

             private object stack;

             void IAsyncStateMachine.MoveNext()

             {

                 int result = default(int);

                 try

                 {

                     bool doFinallyBodies = true;

                     switch (state)

                     {

                         case -:

                             goto Done;

                         case :

                             goto FirstAwaitContinuation;

                         case :

                             goto SecondAwaitContinuation;

                     }

                     // Default case - first call (state is -1)

                     total = ;

                     iterator = text.GetEnumerator();

                 // We really want to jump straight to FirstAwaitRealContinuation, but we can't

                 // goto a label inside a try block...

                 FirstAwaitContinuation:

                     // foreach loop

                     try

                     {

                         // for/foreach loops typically have the condition at the end of the generated code.

                         // We want to go there *unless* we're trying to reach the first continuation.

                         if (state != )

                         {

                             goto LoopCondition;

                         }

                         goto FirstAwaitRealContinuation;

                     LoopBody:

                         ch = iterator.Current;

                         unicode = ch;

                         TaskAwaiter localTaskAwaiter = Task.Delay(unicode).GetAwaiter();

                         if (localTaskAwaiter.IsCompleted)

                         {

                             goto FirstAwaitCompletion;

                         }

                         state = ;

                         taskAwaiter = localTaskAwaiter;

                         builder.AwaitUnsafeOnCompleted(ref localTaskAwaiter, ref this);

                         doFinallyBodies = false;

                         return;

                     FirstAwaitRealContinuation:

                         localTaskAwaiter = taskAwaiter;

                         taskAwaiter = default(TaskAwaiter);

                         state = -;

                     FirstAwaitCompletion:

                         localTaskAwaiter.GetResult();

                         localTaskAwaiter = default(TaskAwaiter);

                         total += unicode;

                     LoopCondition:

                         if (iterator.MoveNext())

                         {

                             goto LoopBody;

                         }

                     }

                     finally

                     {

                         if (doFinallyBodies && iterator != null)

                         {

                             iterator.Dispose();

                         }

                     }

                     // After the loop

                     YieldAwaitable.YieldAwaiter localYieldAwaiter = Task.Yield().GetAwaiter();

                     if (localYieldAwaiter.IsCompleted)

                     {

                         goto SecondAwaitCompletion;

                     }

                     state = ;

                     yieldAwaiter = localYieldAwaiter;

                     builder.AwaitUnsafeOnCompleted(ref localYieldAwaiter, ref this);

                     doFinallyBodies = false;

                     return;

                 SecondAwaitContinuation:

                     localYieldAwaiter = yieldAwaiter;

                     yieldAwaiter = default(YieldAwaitable.YieldAwaiter);

                     state = -;

                     SecondAwaitCompletion:

                     localYieldAwaiter.GetResult();

                     localYieldAwaiter = default(YieldAwaitable.YieldAwaiter);

                     result = total;

                 }

                 catch (Exception ex)

                 {

                     state = -;

                     builder.SetException(ex);

                     return;

                 }

             Done:

                 state = -;

                 builder.SetResult(result);

             }

             [DebuggerHidden]

             void IAsyncStateMachine.SetStateMachine(IAsyncStateMachine machine)

             {

                 builder.SetStateMachine(machine);

             }

         }

     }

巴特西

15.5.2 【Task实现细节】骨架方法的结构

最新文章

热门文章