task async await后续

public ConfiguredTaskAwaitable ConfigureAwait(bool continueOnCapturedContext)
        {
            return new ConfiguredTaskAwaitable(this, continueOnCapturedContext);
        }

public readonly struct ConfiguredTaskAwaitable
        {        
            private readonly ConfiguredTaskAwaitable.ConfiguredTaskAwaiter  m_configuredTaskAwaiter;
            public ConfiguredTaskAwaitable.ConfiguredTaskAwaiter GetAwaiter()
            {
                return m_configuredTaskAwaiter;
            }
            ...
        }

public readonly struct ConfiguredTaskAwaiter : ICriticalNotifyCompletion,  IConfiguredTaskAwaiter
        {
            internal readonly Task m_task;
            internal ConfiguredTaskAwaiter(Task task, bool continueOnCapturedContext)
            {
                Debug.Assert(task != null, "Constructing an awaiter requires a task to  await.");
                m_task = task;
                m_continueOnCapturedContext = continueOnCapturedContext;
            }
            public bool IsCompleted => m_task.IsCompleted;
            public void OnCompleted(Action continuation)
            {
                TaskAwaiter.OnCompletedInternal(m_task, continuation,  m_continueOnCapturedContext, flowExecutionContext: true);
            }
 
            public void UnsafeOnCompleted(Action continuation)
            {
                TaskAwaiter.OnCompletedInternal(m_task, continuation,  m_continueOnCapturedContext, flowExecutionContext: false);
            }
            
            public void GetResult()
            {
                TaskAwaiter.ValidateEnd(m_task);
            }
        }

internal static void AwaitUnsafeOnCompleted(
            ref TAwaiter awaiter, IAsyncStateMachineBox box)
            where TAwaiter : ICriticalNotifyCompletion
        {
            if ((null != (object?)default(TAwaiter)) && (awaiter is ITaskAwaiter))
            {
                ref TaskAwaiter ta = ref Unsafe.As(ref awaiter); //  relies on TaskAwaiter/TaskAwaiter having the same layout
                TaskAwaiter.UnsafeOnCompletedInternal(ta.m_task, box,  continueOnCapturedContext: true);
            }
            else if ((null != (object?)default(TAwaiter)) && (awaiter is  IConfiguredTaskAwaiter))
            {
                ref ConfiguredTaskAwaitable.ConfiguredTaskAwaiter ta = ref  Unsafe.As(ref awaiter);
                TaskAwaiter.UnsafeOnCompletedInternal(ta.m_task, box,  ta.m_continueOnCapturedContext);
            }
            ...
        }

if (continueOnCapturedContext) // 这个就是最开始传入的false，默认为true
            {
                SynchronizationContext? syncCtx = SynchronizationContext.Current;  // 获取SynchronizationContext同步上下文，aspnetcore已经取消了这个对象
                if (syncCtx != null && syncCtx.GetType() !=  typeof(SynchronizationContext))
                {
                    var tc = new SynchronizationContextAwaitTaskContinuation(syncCtx,  stateMachineBox.MoveNextAction, flowExecutionContext: false);
                    if (!AddTaskContinuation(tc, addBeforeOthers: false))
                    {
                        tc.Run(this, canInlineContinuationTask: false); // 最终通过c.m_syncContext.Post(s_postCallback, c.m_action); Post callback
                    }
                    return;
                }
                else
                {
                    TaskScheduler? scheduler = TaskScheduler.InternalCurrent;
                    if (scheduler != null && scheduler != TaskScheduler.Default)
                    {
                        var tc = new TaskSchedulerAwaitTaskContinuation(scheduler,  stateMachineBox.MoveNextAction, flowExecutionContext: false);
                        if (!AddTaskContinuation(tc, addBeforeOthers: false))
                        {
                            tc.Run(this, canInlineContinuationTask: false);
                        }
                        return;
                    }
                }
            } 
            
            if (!AddTaskContinuation(stateMachineBox, addBeforeOthers: false))  // 我们显示指定false，所以会走这个逻辑。
            {
                ThreadPool.UnsafeQueueUserWorkItemInternal(stateMachineBox, preferLocal:  true);
            }