C# Task 是什么？返回值如何实现? Wait如何实现

关于Task的API太多了，网上的实例也很多，现在我们来说说Task究竟是个什么东西【task一般用于多线程，它一定与线程有关】，还有它的返回值有事怎么搞的。

首先我们以一个最简单的API开始，TaskFactory的StartNew<TResult>方法，TaskFactory.cs

public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state){    StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;    Task currTask = Task.InternalCurrent;    return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,        m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);}private TaskScheduler GetDefaultScheduler(Task currTask){    if (m_defaultScheduler != null) return m_defaultScheduler;    else if ((currTask != null)&& ((currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0))        return currTask.ExecutingTaskScheduler;    else return TaskScheduler.Default;}

可见最终和调用Task<TResult>.StartNew等效的，这里的GetDefaultScheduler返回的是TaskScheduler.Default。TaskScheduler.cs实现如下：

public abstract class TaskScheduler{   private static readonly TaskScheduler s_defaultTaskScheduler = new ThreadPoolTaskScheduler();    public static TaskScheduler Default     {        get        {            return s_defaultTaskScheduler;        }    }    internal void InternalQueueTask(Task task)    {        Contract.Requires(task != null);        task.FireTaskScheduledIfNeeded(this);        this.QueueTask(task);    }}

默认的TaskScheduler.Default是ThreadPoolTaskScheduler实例。现在我们看看Task<TResult>的实现 Future.cs

 public class Task<TResult> : Task {   internal static Task<TResult> StartNew(Task parent, Func<object, TResult> function, object state, CancellationToken cancellationToken,            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark)    {        if (function == null)        {            throw new ArgumentNullException("function");        }        if (scheduler == null)        {            throw new ArgumentNullException("scheduler");        }        if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)        {            throw new ArgumentOutOfRangeException("creationOptions", Environment.GetResourceString("TaskT_ctor_SelfReplicating"));        }        // Create and schedule the future.        Task<TResult> f = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler, ref stackMark);        f.ScheduleAndStart(false);        return f;    }   internal void ScheduleAndStart(bool needsProtection)    {        Contract.Assert(m_taskScheduler != null, "expected a task scheduler to have been selected");        Contract.Assert((m_stateFlags & TASK_STATE_STARTED) == 0, "task has already started");        // Set the TASK_STATE_STARTED bit        if (needsProtection)        {            if (!MarkStarted())            {                // A cancel has snuck in before we could get started.  Quietly exit.                return;            }        }        else        {            m_stateFlags |= TASK_STATE_STARTED;        }        if (s_asyncDebuggingEnabled)        {            AddToActiveTasks(this);        }        if (AsyncCausalityTracer.LoggingOn && (Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0)        {            //For all other task than TaskContinuations we want to log. TaskContinuations log in their constructor            AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, this.Id, "Task: "+((Delegate)m_action).Method.Name, 0);        }        try        {            m_taskScheduler.InternalQueueTask(this);        }        catch (ThreadAbortException tae)        {            AddException(tae);            FinishThreadAbortedTask(true, false);        }        catch (Exception e)        {            TaskSchedulerException tse = new TaskSchedulerException(e);            AddException(tse);            Finish(false);            if ((Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0)            {                // m_contingentProperties.m_exceptionsHolder *should* already exist after AddException()                Contract.Assert(                    (m_contingentProperties != null) &&                    (m_contingentProperties.m_exceptionsHolder != null) &&                    (m_contingentProperties.m_exceptionsHolder.ContainsFaultList),                        "Task.ScheduleAndStart(): Expected m_contingentProperties.m_exceptionsHolder to exist " +                        "and to have faults recorded.");                m_contingentProperties.m_exceptionsHolder.MarkAsHandled(false);            }            // re-throw the exception wrapped as a TaskSchedulerException.            throw tse;        }    }            internal Task(        Func<object, TResult> valueSelector, object state, Task parent, CancellationToken cancellationToken,        TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark) :        this(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)    {        PossiblyCaptureContext(ref stackMark);    }    internal void PossiblyCaptureContext(ref StackCrawlMark stackMark)    {        Contract.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null, "Captured an ExecutionContext when one was already captured.");        CapturedContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);    }    internal override void InnerInvoke()    {        // Invoke the delegate        Contract.Assert(m_action != null);        var func = m_action as Func<TResult>;        if (func != null)        {            m_result = func();            return;        }        var funcWithState = m_action as Func<object, TResult>;        if (funcWithState != null)        {            m_result = funcWithState(m_stateObject);            return;        }        Contract.Assert(false, "Invalid m_action in Task<TResult>");    }    public TResult Result    {        get { return IsWaitNotificationEnabledOrNotRanToCompletion ? GetResultCore(waitCompletionNotification: true) : m_result; }    }    }

Task<TResult>的StartNew方法首先调用构造函数，在构造函数里面调用PossiblyCaptureContext方法，PossiblyCaptureContext方法调用ExecutionContext.Capture捕获线程上下文，然后回到StartNew方法，调用Task<TResult>。ScheduleAndStart，ScheduleAndStart方法主要是调用TaskScheduler的InternalQueueTask方法；TaskScheduler的InternalQueueTask方法主要是调用QueueTask，QueueTask方法在子类被覆盖，这里调用ThreadPoolTaskScheduler的QueueTask方法，ThreadPoolTaskScheduler.cs

internal sealed class ThreadPoolTaskScheduler: TaskScheduler{   private static readonly ParameterizedThreadStart s_longRunningThreadWork = new ParameterizedThreadStart(LongRunningThreadWork);    private static void LongRunningThreadWork(object obj)    {        Contract.Requires(obj != null, "TaskScheduler.LongRunningThreadWork: obj is null");        Task t = obj as Task;        Contract.Assert(t != null, "TaskScheduler.LongRunningThreadWork: t is null");        t.ExecuteEntry(false);    }    protected internal override void QueueTask(Task task)    {        if ((task.Options & TaskCreationOptions.LongRunning) != 0)        {            // Run LongRunning tasks on their own dedicated thread.            Thread thread = new Thread(s_longRunningThreadWork);            thread.IsBackground = true; // Keep this thread from blocking process shutdown            thread.Start(task);        }        else        {            // Normal handling for non-LongRunning tasks.            bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0);            ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue);        }    }}

如果Task是TaskCreationOptions.LongRunning，那么我们新建一个逻辑线程来运行当前的Task，否者放到线程池里面运行。

单独的逻辑线程调用s_longRunningThreadWork回调方法【该方法调用task的ExecuteEntry】；如果是线程池那么我们调用Task的ExecuteWorkItem方法【其实还是调用Task的ExecuteEntry】，Task.cs

public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable{    [ThreadStatic]    internal static Task t_currentTask;     internal static Task InternalCurrent    {        get { return t_currentTask; }    }   void IThreadPoolWorkItem.ExecuteWorkItem()    {        ExecuteEntry(false);    }    internal bool ExecuteEntry(bool bPreventDoubleExecution)    {        if (bPreventDoubleExecution || ((Options & (TaskCreationOptions)InternalTaskOptions.SelfReplicating) != 0))        {            int previousState = 0;            // Do atomic state transition from queued to invoked. If we observe a task that's already invoked,            // we will return false so that TaskScheduler.ExecuteTask can throw an exception back to the custom scheduler.            // However we don't want this exception to be throw if the task was already canceled, because it's a            // legitimate scenario for custom schedulers to dequeue a task and mark it as canceled (example: throttling scheduler)            if (!AtomicStateUpdate(TASK_STATE_DELEGATE_INVOKED,                                   TASK_STATE_DELEGATE_INVOKED | TASK_STATE_COMPLETED_MASK,                                   ref previousState) && (previousState & TASK_STATE_CANCELED) == 0)            {                // This task has already been invoked.  Don't invoke it again.                return false;            }        }        else        {            // Remember that we started running the task delegate.            m_stateFlags |= TASK_STATE_DELEGATE_INVOKED;        }        if (!IsCancellationRequested && !IsCanceled)        {            ExecuteWithThreadLocal(ref t_currentTask);        }        else if (!IsCanceled)        {            int prevState = Interlocked.Exchange(ref m_stateFlags, m_stateFlags | TASK_STATE_CANCELED);            if ((prevState & TASK_STATE_CANCELED) == 0)            {                CancellationCleanupLogic();            }        }        return true;    }   private void ExecuteWithThreadLocal(ref Task currentTaskSlot)    {        // Remember the current task so we can restore it after running, and then        Task previousTask = currentTaskSlot;        // ETW event for Task Started        var etwLog = TplEtwProvider.Log;        Guid savedActivityID = new Guid();        bool etwIsEnabled = etwLog.IsEnabled();        if (etwIsEnabled)        {            if (etwLog.TasksSetActivityIds)                EventSource.SetCurrentThreadActivityId(TplEtwProvider.CreateGuidForTaskID(this.Id), out savedActivityID);            // previousTask holds the actual "current task" we want to report in the event            if (previousTask != null)                etwLog.TaskStarted(previousTask.m_taskScheduler.Id, previousTask.Id, this.Id);            else                etwLog.TaskStarted(TaskScheduler.Current.Id, 0, this.Id);        }        if (AsyncCausalityTracer.LoggingOn)            AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.Execution);        try        {            // place the current task into TLS.            currentTaskSlot = this;            ExecutionContext ec = CapturedContext;            if (ec == null)            {                // No context, just run the task directly.                Execute();            }            else            {                if (IsSelfReplicatingRoot || IsChildReplica)                {                    CapturedContext = CopyExecutionContext(ec);                }                // Run the task.  We need a simple shim that converts the                // object back into a Task object, so that we can Execute it.                // Lazily initialize the callback delegate; benign ----                var callback = s_ecCallback;                if (callback == null) s_ecCallback = callback = new ContextCallback(ExecutionContextCallback);#if PFX_LEGACY_3_5                ExecutionContext.Run(ec, callback, this);#else                ExecutionContext.Run(ec, callback, this, true);#endif            }            if (AsyncCausalityTracer.LoggingOn)                AsyncCausalityTracer.TraceSynchronousWorkCompletion(CausalityTraceLevel.Required, CausalitySynchronousWork.Execution);            Finish(true);        }        finally        {            currentTaskSlot = previousTask;                        // ETW event for Task Completed            if (etwIsEnabled)            {                // previousTask holds the actual "current task" we want to report in the event                if (previousTask != null)                    etwLog.TaskCompleted(previousTask.m_taskScheduler.Id, previousTask.Id, this.Id, IsFaulted);                else                    etwLog.TaskCompleted(TaskScheduler.Current.Id, 0, this.Id, IsFaulted);                if (etwLog.TasksSetActivityIds)                    EventSource.SetCurrentThreadActivityId(savedActivityID);            }        }    }   private static void ExecutionContextCallback(object obj)    {        Task task = obj as Task;        Contract.Assert(task != null, "expected a task object");        task.Execute();    }    private void Execute()    {        if (IsSelfReplicatingRoot)        {            ExecuteSelfReplicating(this);        }        else        {            try            {                InnerInvoke();            }            catch (ThreadAbortException tae)            {                // Don't record the TAE or call FinishThreadAbortedTask for a child replica task --                // it's already been done downstream.                if (!IsChildReplica)                {                    // Record this exception in the task's exception list                    HandleException(tae);                    // This is a ThreadAbortException and it will be rethrown from this catch clause, causing us to                     // skip the regular Finish codepath. In order not to leave the task unfinished, we now call                     // FinishThreadAbortedTask here.                    FinishThreadAbortedTask(true, true);                }            }            catch (Exception exn)            {                // Record this exception in the task's exception list                HandleException(exn);            }        }    }}

到这里Task是什么 就明白了，继续往下看，Task的ExecuteEntry方法主要是调用ExecutionContext.Run(ec, callback, this, true)方法，注意这里的callback是一个ContextCallback实例，里面主要是调用Task的Execute方法，Task的Execute主要是代用InnerInvoke方法，该方法在子类Task<TResult>被重写，InnerInvoke方法里面有2局比较重要【m_result = func() 或者m_result = funcWithState(m_stateObject) 这里才是正真调用我们自己的方法，给返回值赋值】，到这里返回值也就明白了。那么在我们方法结束后需要调用Finish方法来标记方法结束

/// <summary>    /// Signals completion of this particular task.    /// The bUserDelegateExecuted parameter indicates whether this Finish() call comes following the    /// full execution of the user delegate.     /// If bUserDelegateExecuted is false, it mean user delegate wasn't invoked at all (either due to    /// a cancellation request, or because this task is a promise style Task). In this case, the steps    /// involving child tasks (i.e. WaitForChildren) will be skipped.    ///     /// </summary>    internal void Finish(bool bUserDelegateExecuted)    {        if (!bUserDelegateExecuted)        {            // delegate didn't execute => no children. We can safely call the remaining finish stages            FinishStageTwo();        }        else        {            var props = m_contingentProperties;            if (props == null || // no contingent properties means no children, so it's safe to complete ourselves                (props.m_completionCountdown == 1 && !IsSelfReplicatingRoot) ||                // Count of 1 => either all children finished, or there were none. Safe to complete ourselves                 // without paying the price of an Interlocked.Decrement.                // However we need to exclude self replicating root tasks from this optimization, because                // they can have children joining in, or finishing even after the root task delegate is done.                Interlocked.Decrement(ref props.m_completionCountdown) == 0) // Reaching this sub clause means there may be remaining active children,            // and we could be racing with one of them to call FinishStageTwo().            // So whoever does the final Interlocked.Dec is responsible to finish.            {                FinishStageTwo();            }            else            {                // Apparently some children still remain. It will be up to the last one to process the completion of this task on their own thread.                // We will now yield the thread back to ThreadPool. Mark our state appropriately before getting out.                // We have to use an atomic update for this and make sure not to overwrite a final state,                 // because at this very moment the last child's thread may be concurrently completing us.                // Otherwise we risk overwriting the TASK_STATE_RAN_TO_COMPLETION, _CANCELED or _FAULTED bit which may have been set by that child task.                // Note that the concurrent update by the last child happening in FinishStageTwo could still wipe out the TASK_STATE_WAITING_ON_CHILDREN flag,                 // but it is not critical to maintain, therefore we dont' need to intruduce a full atomic update into FinishStageTwo                AtomicStateUpdate(TASK_STATE_WAITING_ON_CHILDREN, TASK_STATE_FAULTED | TASK_STATE_CANCELED | TASK_STATE_RAN_TO_COMPLETION);            }            // Now is the time to prune exceptional children. We'll walk the list and removes the ones whose exceptions we might have observed after they threw.            // we use a local variable for exceptional children here because some other thread may be nulling out m_contingentProperties.m_exceptionalChildren             List<Task> exceptionalChildren = props != null ? props.m_exceptionalChildren : null;            if (exceptionalChildren != null)            {                lock (exceptionalChildren)                {                    exceptionalChildren.RemoveAll(s_IsExceptionObservedByParentPredicate); // RemoveAll has better performance than doing it ourselves                }            }        }    }    internal void FinishStageTwo()    {        AddExceptionsFromChildren();        // At this point, the task is done executing and waiting for its children,        // we can transition our task to a completion state.          int completionState;        if (ExceptionRecorded)        {            completionState = TASK_STATE_FAULTED;            if (AsyncCausalityTracer.LoggingOn)                AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Error);            if (Task.s_asyncDebuggingEnabled)            {                RemoveFromActiveTasks(this.Id);            }        }        else if (IsCancellationRequested && IsCancellationAcknowledged)        {            // We transition into the TASK_STATE_CANCELED final state if the task's CT was signalled for cancellation,             // and the user delegate acknowledged the cancellation request by throwing an OCE,             // and the task hasn't otherwise transitioned into faulted state. (TASK_STATE_FAULTED trumps TASK_STATE_CANCELED)            //            // If the task threw an OCE without cancellation being requestsed (while the CT not being in signaled state),            // then we regard it as a regular exception            completionState = TASK_STATE_CANCELED;            if (AsyncCausalityTracer.LoggingOn)                AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Canceled);            if (Task.s_asyncDebuggingEnabled)            {                RemoveFromActiveTasks(this.Id);            }        }        else        {            completionState = TASK_STATE_RAN_TO_COMPLETION;            if (AsyncCausalityTracer.LoggingOn)                AsyncCausalityTracer.TraceOperationCompletion(CausalityTraceLevel.Required, this.Id, AsyncCausalityStatus.Completed);            if (Task.s_asyncDebuggingEnabled)            {                RemoveFromActiveTasks(this.Id);            }        }        // Use Interlocked.Exchange() to effect a memory fence, preventing        // any SetCompleted() (or later) instructions from sneak back before it.        Interlocked.Exchange(ref m_stateFlags, m_stateFlags | completionState);        // Set the completion event if it's been lazy allocated.        // And if we made a cancellation registration, it's now unnecessary.        var cp = m_contingentProperties;        if (cp != null)        {            cp.SetCompleted();            cp.DeregisterCancellationCallback();        }        // ready to run continuations and notify parent.        FinishStageThree();    }    internal bool AtomicStateUpdate(int newBits, int illegalBits)    {        // This could be implemented in terms of:        //     internal bool AtomicStateUpdate(int newBits, int illegalBits, ref int oldFlags);        // but for high-throughput perf, that delegation's cost is noticeable.        SpinWait sw = new SpinWait();        do        {            int oldFlags = m_stateFlags;            if ((oldFlags & illegalBits) != 0) return false;            if (Interlocked.CompareExchange(ref m_stateFlags, oldFlags | newBits, oldFlags) == oldFlags)            {                return true;            }            sw.SpinOnce();        } while (true);    }

在FinishStageTwo方法后面还会调用FinishStageThree方法，FinishStageThree方法调用FinishContinuations，在FinishContinuations方法里面会获取object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);然后再用对应的方法.

internal void FinishStageThree(){    // Release the action so that holding this task object alive doesn't also    // hold alive the body of the task.  We do this before notifying a parent,    // so that if notifying the parent completes the parent and causes    // its synchronous continuations to run, the GC can collect the state    // in the interim.  And we do it before finishing continuations, because    // continuations hold onto the task, and therefore are keeping it alive.    m_action = null;    // Notify parent if this was an attached task    if (m_parent != null         && ((m_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0)         && (((TaskCreationOptions)(m_stateFlags & OptionsMask)) & TaskCreationOptions.AttachedToParent) != 0)    {        m_parent.ProcessChildCompletion(this);    }    // Activate continuations (if any).    FinishContinuations();}internal void FinishContinuations(){    // Atomically store the fact that this task is completing.  From this point on, the adding of continuations will    // result in the continuations being run/launched directly rather than being added to the continuation list.    object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);    TplEtwProvider.Log.RunningContinuation(Id, continuationObject);    // If continuationObject == null, then we don't have any continuations to process    if (continuationObject != null)    {        if (AsyncCausalityTracer.LoggingOn)            AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.CompletionNotification);        // Skip synchronous execution of continuations if this task's thread was aborted        bool bCanInlineContinuations = !(((m_stateFlags & TASK_STATE_THREAD_WAS_ABORTED) != 0) ||                                          (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) ||                                          ((m_stateFlags & (int)TaskCreationOptions.RunContinuationsAsynchronously) != 0));        // Handle the single-Action case        Action singleAction = continuationObject as Action;        if (singleAction != null)        {            AwaitTaskContinuation.RunOrScheduleAction(singleAction, bCanInlineContinuations, ref t_currentTask);            LogFinishCompletionNotification();            return;        }        // Handle the single-ITaskCompletionAction case        ITaskCompletionAction singleTaskCompletionAction = continuationObject as ITaskCompletionAction;        if (singleTaskCompletionAction != null)        {            if (bCanInlineContinuations)            {                singleTaskCompletionAction.Invoke(this);            }            else            {                ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false);            }            LogFinishCompletionNotification();            return;        }        // Handle the single-TaskContinuation case        TaskContinuation singleTaskContinuation = continuationObject as TaskContinuation;        if (singleTaskContinuation != null)        {            singleTaskContinuation.Run(this, bCanInlineContinuations);            LogFinishCompletionNotification();            return;        }        // Not a single; attempt to cast as list        List<object> continuations = continuationObject as List<object>;        if (continuations == null)        {            LogFinishCompletionNotification();            return;  // Not a single or a list; just return        }        //        // Begin processing of continuation list        //        // Wait for any concurrent adds or removes to be retired        lock (continuations) { }        int continuationCount = continuations.Count;        // Fire the asynchronous continuations first ...        for (int i = 0; i < continuationCount; i++)        {            // Synchronous continuation tasks will have the ExecuteSynchronously option,            // and we're looking for asynchronous tasks...            var tc = continuations[i] as StandardTaskContinuation;            if (tc != null && (tc.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0)            {                TplEtwProvider.Log.RunningContinuationList(Id, i, tc);                continuations[i] = null; // so that we can skip this later                tc.Run(this, bCanInlineContinuations);            }        }        // ... and then fire the synchronous continuations (if there are any).        // This includes ITaskCompletionAction, AwaitTaskContinuations, and        // Action delegates, which are all by default implicitly synchronous.        for (int i = 0; i < continuationCount; i++)        {            object currentContinuation = continuations[i];            if (currentContinuation == null) continue;            continuations[i] = null; // to enable free'ing up memory earlier            TplEtwProvider.Log.RunningContinuationList(Id, i, currentContinuation);            // If the continuation is an Action delegate, it came from an await continuation,            // and we should use AwaitTaskContinuation to run it.            Action ad = currentContinuation as Action;            if (ad != null)            {                AwaitTaskContinuation.RunOrScheduleAction(ad, bCanInlineContinuations, ref t_currentTask);            }            else            {                // If it's a TaskContinuation object of some kind, invoke it.                TaskContinuation tc = currentContinuation as TaskContinuation;                if (tc != null)                {                    // We know that this is a synchronous continuation because the                    // asynchronous ones have been weeded out                    tc.Run(this, bCanInlineContinuations);                }                // Otherwise, it must be an ITaskCompletionAction, so invoke it.                else                {                    Contract.Assert(currentContinuation is ITaskCompletionAction, "Expected continuation element to be Action, TaskContinuation, or ITaskContinuationAction");                    var action = (ITaskCompletionAction)currentContinuation;                    if (bCanInlineContinuations)                    {                        action.Invoke(this);                    }                    else                    {                        ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false);                    }                }            }        }        LogFinishCompletionNotification();    }}

当我们访问TTask<TResult> 的Result的时候，如果Task还没有执行完毕，那么我们必须等待TASK，调用Task<TResult>的GetResultCore(waitCompletionNotification: true)方法,该方法最终调用Task的InternalWait方法。

/// The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where     /// the current context is known or cached.    internal bool InternalWait(int millisecondsTimeout, CancellationToken cancellationToken)    {        // ETW event for Task Wait Begin        var etwLog = TplEtwProvider.Log;        bool etwIsEnabled = etwLog.IsEnabled();        if (etwIsEnabled)        {            Task currentTask = Task.InternalCurrent;            etwLog.TaskWaitBegin(                (currentTask != null ? currentTask.m_taskScheduler.Id : TaskScheduler.Default.Id), (currentTask != null ? currentTask.Id : 0),                this.Id, TplEtwProvider.TaskWaitBehavior.Synchronous, 0, System.Threading.Thread.GetDomainID());        }        bool returnValue = IsCompleted;        // If the event hasn't already been set, we will wait.        if (!returnValue)        {            // Alert a listening debugger that we can't make forward progress unless it slips threads.            // We call NOCTD for two reasons:            //    1. If the task runs on another thread, then we'll be blocked here indefinitely.            //    2. If the task runs inline but takes some time to complete, it will suffer ThreadAbort with possible state corruption,            //       and it is best to prevent this unless the user explicitly asks to view the value with thread-slipping enabled.            Debugger.NotifyOfCrossThreadDependency();            // We will attempt inline execution only if an infinite wait was requested            // Inline execution doesn't make sense for finite timeouts and if a cancellation token was specified            // because we don't know how long the task delegate will take.            if (millisecondsTimeout == Timeout.Infinite && !cancellationToken.CanBeCanceled &&                WrappedTryRunInline() && IsCompleted) // TryRunInline doesn't guarantee completion, as there may be unfinished children.            {                returnValue = true;            }            else            {                returnValue = SpinThenBlockingWait(millisecondsTimeout, cancellationToken);            }        }        Contract.Assert(IsCompleted || millisecondsTimeout != Timeout.Infinite);        // ETW event for Task Wait End        if (etwIsEnabled)        {            Task currentTask = Task.InternalCurrent;            if (currentTask != null)            {                etwLog.TaskWaitEnd(currentTask.m_taskScheduler.Id, currentTask.Id, this.Id);            }            else            {                etwLog.TaskWaitEnd(TaskScheduler.Default.Id, 0, this.Id);            }            // logically the continuation is empty so we immediately fire            etwLog.TaskWaitContinuationComplete(this.Id);        }        return returnValue;    }  /// Waits for the task to complete, for a timeout to occur, or for cancellation to be requested.  /// The method first spins and then falls back to blocking on a new event.   private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken cancellationToken)    {        bool infiniteWait = millisecondsTimeout == Timeout.Infinite;        uint startTimeTicks = infiniteWait ? 0 : (uint)Environment.TickCount;        bool returnValue = SpinWait(millisecondsTimeout);        if (!returnValue)        {            var mres = new SetOnInvokeMres();            try            {                AddCompletionAction(mres, addBeforeOthers: true);                if (infiniteWait)                {                    returnValue = mres.Wait(Timeout.Infinite, cancellationToken);                }                else                {                    uint elapsedTimeTicks = ((uint)Environment.TickCount) - startTimeTicks;                    if (elapsedTimeTicks < millisecondsTimeout)                    {                        returnValue = mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken);                    }                }            }            finally            {                if (!IsCompleted) RemoveContinuation(mres);                // Don't Dispose of the MRES, because the continuation off of this task may                // still be running.  This is ok, however, as we never access the MRES' WaitHandle,                // and thus no finalizable resources are actually allocated.            }        }        return returnValue;    }    private void AddCompletionAction(ITaskCompletionAction action, bool addBeforeOthers)    {        if (!AddTaskContinuation(action, addBeforeOthers))            action.Invoke(this); // run the action directly if we failed to queue the continuation (i.e., the task completed)    }       // Record a continuation task or action.   // Return true if and only if we successfully queued a continuation.   private bool AddTaskContinuation(object tc, bool addBeforeOthers)    {        Contract.Requires(tc != null);        // Make sure that, if someone calls ContinueWith() right after waiting for the predecessor to complete,        // we don't queue up a continuation.        if (IsCompleted) return false;        // Try to just jam tc into m_continuationObject        if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))        {            // If we get here, it means that we failed to CAS tc into m_continuationObject.            // Therefore, we must go the more complicated route.            return AddTaskContinuationComplex(tc, addBeforeOthers);        }        else return true;    }    private sealed class SetOnInvokeMres : ManualResetEventSlim, ITaskCompletionAction    {        internal SetOnInvokeMres() : base(false, 0) { }        public void Invoke(Task completingTask) { Set(); }    }

SpinThenBlockingWait方法先自旋检查是否完成，如果没有调用SetOnInvokeMres实例来完成Wait【SetOnInvokeMres是ManualResetEventSlim的子类，这里调用 mres.Wait(Timeout.Infinite, cancellationToken) 或者 mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken)来实现阻塞】，但是这里有一个AddCompletionAction方法，然后调用AddTaskContinuation方法，在AddTaskContinuation方法中有一句很重要【if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))】说白了就是把SetOnInvokeMres实例赋给m_continuationObject对象。所以AddCompletionAction方法里面的action.Invoke(this);放法在这里没有调用。而是等待task执行完毕后FinishContinuations方法中的singleTaskCompletionAction.Invoke(this);设置信号量,如果m_continuationObject是真正的TaskContinuation实例，我们就调用【    singleTaskContinuation.Run(this, bCanInlineContinuations)】

我们简单总结一下一下调用次序：

TaskFactory.StartNew 
->Task<TResult>.StartNew【该方法首先调用构造函数，构造函数里面调用PossiblyCaptureContext来捕获线程上下文，然后调用自己的ScheduleAndStart方法】
->TaskScheduler.InternalQueueTask 
->ThreadPoolTaskScheduler.QueueTask【到这里Task就转换为线程了】
->Task.ExecuteEntry【如果是线程池是通过调用IThreadPoolWorkItem的ExecuteWorkItem方法进入的】
->Task.ExecuteWithThreadLocal【该方法首先拷贝捕获到的线程上下文，再调用ExecutionContext.Run，传入上传下文和回调方法】
->Task.ExecutionContextCallback 
->Task.Execute 
->Task<TResult>.InnerInvoke【该方法会真正调用我们自己的方法，并且给返回值赋值】
->Task.Finish 【标记该Task已经结束】
->Task.FinishStageTwo
->Task.FinishStageThree
->Task.FinishContinuations【会触发SET】
-------------------------
Task<TResult>的Result属性，就是Task的返回值，如果Task执行完毕直接返回，否者调用Task<TResult>.GetResultCore
->Task.InternalWait
->Task.SpinThenBlockingWait【调用SetOnInvokeMres的Wait方法】

internal void FinishStageThree(){    // Release the action so that holding this task object alive doesn't also    // hold alive the body of the task.  We do this before notifying a parent,    // so that if notifying the parent completes the parent and causes    // its synchronous continuations to run, the GC can collect the state    // in the interim.  And we do it before finishing continuations, because    // continuations hold onto the task, and therefore are keeping it alive.    m_action = null;    // Notify parent if this was an attached task    if (m_parent != null         && ((m_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0)         && (((TaskCreationOptions)(m_stateFlags & OptionsMask)) & TaskCreationOptions.AttachedToParent) != 0)    {        m_parent.ProcessChildCompletion(this);    }    // Activate continuations (if any).    FinishContinuations();}internal void FinishContinuations(){    // Atomically store the fact that this task is completing.  From this point on, the adding of continuations will    // result in the continuations being run/launched directly rather than being added to the continuation list.    object continuationObject = Interlocked.Exchange(ref m_continuationObject, s_taskCompletionSentinel);    TplEtwProvider.Log.RunningContinuation(Id, continuationObject);    // If continuationObject == null, then we don't have any continuations to process    if (continuationObject != null)    {        if (AsyncCausalityTracer.LoggingOn)            AsyncCausalityTracer.TraceSynchronousWorkStart(CausalityTraceLevel.Required, this.Id, CausalitySynchronousWork.CompletionNotification);        // Skip synchronous execution of continuations if this task's thread was aborted        bool bCanInlineContinuations = !(((m_stateFlags & TASK_STATE_THREAD_WAS_ABORTED) != 0) ||                                          (Thread.CurrentThread.ThreadState == ThreadState.AbortRequested) ||                                          ((m_stateFlags & (int)TaskCreationOptions.RunContinuationsAsynchronously) != 0));        // Handle the single-Action case        Action singleAction = continuationObject as Action;        if (singleAction != null)        {            AwaitTaskContinuation.RunOrScheduleAction(singleAction, bCanInlineContinuations, ref t_currentTask);            LogFinishCompletionNotification();            return;        }        // Handle the single-ITaskCompletionAction case        ITaskCompletionAction singleTaskCompletionAction = continuationObject as ITaskCompletionAction;        if (singleTaskCompletionAction != null)        {            if (bCanInlineContinuations)            {                singleTaskCompletionAction.Invoke(this);            }            else            {                ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(singleTaskCompletionAction, this), forceGlobal: false);            }            LogFinishCompletionNotification();            return;        }        // Handle the single-TaskContinuation case        TaskContinuation singleTaskContinuation = continuationObject as TaskContinuation;        if (singleTaskContinuation != null)        {            singleTaskContinuation.Run(this, bCanInlineContinuations);            LogFinishCompletionNotification();            return;        }        // Not a single; attempt to cast as list        List<object> continuations = continuationObject as List<object>;        if (continuations == null)        {            LogFinishCompletionNotification();            return;  // Not a single or a list; just return        }        //        // Begin processing of continuation list        //        // Wait for any concurrent adds or removes to be retired        lock (continuations) { }        int continuationCount = continuations.Count;        // Fire the asynchronous continuations first ...        for (int i = 0; i < continuationCount; i++)        {            // Synchronous continuation tasks will have the ExecuteSynchronously option,            // and we're looking for asynchronous tasks...            var tc = continuations[i] as StandardTaskContinuation;            if (tc != null && (tc.m_options & TaskContinuationOptions.ExecuteSynchronously) == 0)            {                TplEtwProvider.Log.RunningContinuationList(Id, i, tc);                continuations[i] = null; // so that we can skip this later                tc.Run(this, bCanInlineContinuations);            }        }        // ... and then fire the synchronous continuations (if there are any).        // This includes ITaskCompletionAction, AwaitTaskContinuations, and        // Action delegates, which are all by default implicitly synchronous.        for (int i = 0; i < continuationCount; i++)        {            object currentContinuation = continuations[i];            if (currentContinuation == null) continue;            continuations[i] = null; // to enable free'ing up memory earlier            TplEtwProvider.Log.RunningContinuationList(Id, i, currentContinuation);            // If the continuation is an Action delegate, it came from an await continuation,            // and we should use AwaitTaskContinuation to run it.            Action ad = currentContinuation as Action;            if (ad != null)            {                AwaitTaskContinuation.RunOrScheduleAction(ad, bCanInlineContinuations, ref t_currentTask);            }            else            {                // If it's a TaskContinuation object of some kind, invoke it.                TaskContinuation tc = currentContinuation as TaskContinuation;                if (tc != null)                {                    // We know that this is a synchronous continuation because the                    // asynchronous ones have been weeded out                    tc.Run(this, bCanInlineContinuations);                }                // Otherwise, it must be an ITaskCompletionAction, so invoke it.                else                {                    Contract.Assert(currentContinuation is ITaskCompletionAction, "Expected continuation element to be Action, TaskContinuation, or ITaskContinuationAction");                    var action = (ITaskCompletionAction)currentContinuation;                    if (bCanInlineContinuations)                    {                        action.Invoke(this);                    }                    else                    {                        ThreadPool.UnsafeQueueCustomWorkItem(new CompletionActionInvoker(action, this), forceGlobal: false);                    }                }            }        }        LogFinishCompletionNotification();    }}

当我们访问TTask<TResult> 的Result的时候，如果Task还没有执行完毕，那么我们必须等待TASK，调用Task<TResult>的GetResultCore(waitCompletionNotification: true)方法,该方法最终调用Task的InternalWait方法。

/// The core wait function, which is only accesible internally. It's meant to be used in places in TPL code where     /// the current context is known or cached.    internal bool InternalWait(int millisecondsTimeout, CancellationToken cancellationToken)    {        // ETW event for Task Wait Begin        var etwLog = TplEtwProvider.Log;        bool etwIsEnabled = etwLog.IsEnabled();        if (etwIsEnabled)        {            Task currentTask = Task.InternalCurrent;            etwLog.TaskWaitBegin(                (currentTask != null ? currentTask.m_taskScheduler.Id : TaskScheduler.Default.Id), (currentTask != null ? currentTask.Id : 0),                this.Id, TplEtwProvider.TaskWaitBehavior.Synchronous, 0, System.Threading.Thread.GetDomainID());        }        bool returnValue = IsCompleted;        // If the event hasn't already been set, we will wait.        if (!returnValue)        {            // Alert a listening debugger that we can't make forward progress unless it slips threads.            // We call NOCTD for two reasons:            //    1. If the task runs on another thread, then we'll be blocked here indefinitely.            //    2. If the task runs inline but takes some time to complete, it will suffer ThreadAbort with possible state corruption,            //       and it is best to prevent this unless the user explicitly asks to view the value with thread-slipping enabled.            Debugger.NotifyOfCrossThreadDependency();            // We will attempt inline execution only if an infinite wait was requested            // Inline execution doesn't make sense for finite timeouts and if a cancellation token was specified            // because we don't know how long the task delegate will take.            if (millisecondsTimeout == Timeout.Infinite && !cancellationToken.CanBeCanceled &&                WrappedTryRunInline() && IsCompleted) // TryRunInline doesn't guarantee completion, as there may be unfinished children.            {                returnValue = true;            }            else            {                returnValue = SpinThenBlockingWait(millisecondsTimeout, cancellationToken);            }        }        Contract.Assert(IsCompleted || millisecondsTimeout != Timeout.Infinite);        // ETW event for Task Wait End        if (etwIsEnabled)        {            Task currentTask = Task.InternalCurrent;            if (currentTask != null)            {                etwLog.TaskWaitEnd(currentTask.m_taskScheduler.Id, currentTask.Id, this.Id);            }            else            {                etwLog.TaskWaitEnd(TaskScheduler.Default.Id, 0, this.Id);            }            // logically the continuation is empty so we immediately fire            etwLog.TaskWaitContinuationComplete(this.Id);        }        return returnValue;    }  /// Waits for the task to complete, for a timeout to occur, or for cancellation to be requested.  /// The method first spins and then falls back to blocking on a new event.   private bool SpinThenBlockingWait(int millisecondsTimeout, CancellationToken cancellationToken)    {        bool infiniteWait = millisecondsTimeout == Timeout.Infinite;        uint startTimeTicks = infiniteWait ? 0 : (uint)Environment.TickCount;        bool returnValue = SpinWait(millisecondsTimeout);        if (!returnValue)        {            var mres = new SetOnInvokeMres();            try            {                AddCompletionAction(mres, addBeforeOthers: true);                if (infiniteWait)                {                    returnValue = mres.Wait(Timeout.Infinite, cancellationToken);                }                else                {                    uint elapsedTimeTicks = ((uint)Environment.TickCount) - startTimeTicks;                    if (elapsedTimeTicks < millisecondsTimeout)                    {                        returnValue = mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken);                    }                }            }            finally            {                if (!IsCompleted) RemoveContinuation(mres);                // Don't Dispose of the MRES, because the continuation off of this task may                // still be running.  This is ok, however, as we never access the MRES' WaitHandle,                // and thus no finalizable resources are actually allocated.            }        }        return returnValue;    }    private void AddCompletionAction(ITaskCompletionAction action, bool addBeforeOthers)    {        if (!AddTaskContinuation(action, addBeforeOthers))            action.Invoke(this); // run the action directly if we failed to queue the continuation (i.e., the task completed)    }       // Record a continuation task or action.   // Return true if and only if we successfully queued a continuation.   private bool AddTaskContinuation(object tc, bool addBeforeOthers)    {        Contract.Requires(tc != null);        // Make sure that, if someone calls ContinueWith() right after waiting for the predecessor to complete,        // we don't queue up a continuation.        if (IsCompleted) return false;        // Try to just jam tc into m_continuationObject        if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))        {            // If we get here, it means that we failed to CAS tc into m_continuationObject.            // Therefore, we must go the more complicated route.            return AddTaskContinuationComplex(tc, addBeforeOthers);        }        else return true;    }    private sealed class SetOnInvokeMres : ManualResetEventSlim, ITaskCompletionAction    {        internal SetOnInvokeMres() : base(false, 0) { }        public void Invoke(Task completingTask) { Set(); }    }

SpinThenBlockingWait方法先自旋检查是否完成，如果没有调用SetOnInvokeMres实例来完成Wait【SetOnInvokeMres是ManualResetEventSlim的子类，这里调用 mres.Wait(Timeout.Infinite, cancellationToken) 或者 mres.Wait((int)(millisecondsTimeout - elapsedTimeTicks), cancellationToken)来实现阻塞】，但是这里有一个AddCompletionAction方法，然后调用AddTaskContinuation方法，在AddTaskContinuation方法中有一句很重要【if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))】说白了就是把SetOnInvokeMres实例赋给m_continuationObject对象。所以AddCompletionAction方法里面的action.Invoke(this);放法在这里没有调用。而是等待task执行完毕后FinishContinuations方法中的singleTaskCompletionAction.Invoke(this);设置信号量,如果m_continuationObject是真正的TaskContinuation实例，我们就调用【    singleTaskContinuation.Run(this, bCanInlineContinuations)】

我们简单总结一下一下调用次序：

TaskFactory.StartNew 
->Task<TResult>.StartNew【该方法首先调用构造函数，构造函数里面调用PossiblyCaptureContext来捕获线程上下文，然后调用自己的ScheduleAndStart方法】
->TaskScheduler.InternalQueueTask 
->ThreadPoolTaskScheduler.QueueTask【到这里Task就转换为线程了】
->Task.ExecuteEntry【如果是线程池是通过调用IThreadPoolWorkItem的ExecuteWorkItem方法进入的】
->Task.ExecuteWithThreadLocal【该方法首先拷贝捕获到的线程上下文，再调用ExecutionContext.Run，传入上传下文和回调方法】
->Task.ExecutionContextCallback 
->Task.Execute 
->Task<TResult>.InnerInvoke【该方法会真正调用我们自己的方法，并且给返回值赋值】
->Task.Finish 【标记该Task已经结束】
->Task.FinishStageTwo
->Task.FinishStageThree
->Task.FinishContinuations【会触发SET】
-------------------------
Task<TResult>的Result属性，就是Task的返回值，如果Task执行完毕直接返回，否者调用Task<TResult>.GetResultCore
->Task.InternalWait
->Task.SpinThenBlockingWait【调用SetOnInvokeMres的Wait方法】