看了上一篇C# Task 是什么？返回值如何实现? Wait如何实现 我们提到FinishContinuations方法中会调用TaskContinuation实例，那么我们的ContinueWith就应该非常简单，只需要把TASK放到TaskContinuation结合中就可以了，ContinueWith可以是 Action<Task<TResult>>也可以是 Func<Task<TResult>,TNewResult> ，其中Task<TResult>的实现如下：
public class Task<TResult> : Task{
//Creates a continuation that executes when the target Task{TResult}" completes
public Task ContinueWith(Action<Task<TResult>> continuationAction)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return ContinueWith(continuationAction, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
}
internal Task ContinueWith(Action<Task<TResult>> continuationAction, TaskScheduler scheduler, CancellationToken cancellationToken,TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
{
if (continuationAction == null)
{
throw new ArgumentNullException("continuationAction");
}
if (scheduler == null)
{
throw new ArgumentNullException("scheduler");
}
TaskCreationOptions creationOptions;
InternalTaskOptions internalOptions;
CreationOptionsFromContinuationOptions(continuationOptions,out creationOptions,out internalOptions);
Task continuationTask = new ContinuationTaskFromResultTask<TResult>(this, continuationAction, null, creationOptions, internalOptions,ref stackMark);
ContinueWithCore(continuationTask, scheduler, cancellationToken, continuationOptions);
return continuationTask;
}
public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default(CancellationToken), TaskContinuationOptions.None, ref stackMark);
}
// Same as the above overload, just with a stack mark.
internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, ref StackCrawlMark stackMark)
{
if (continuationFunction == null)
{
throw new ArgumentNullException("continuationFunction");
}
if (scheduler == null)
{
throw new ArgumentNullException("scheduler");
}
TaskCreationOptions creationOptions;
InternalTaskOptions internalOptions;
CreationOptionsFromContinuationOptions(continuationOptions,out creationOptions,out internalOptions);
Task<TNewResult> continuationFuture = new ContinuationResultTaskFromResultTask<TResult,TNewResult>(this, continuationFunction, state,creationOptions, internalOptions,ref stackMark);
ContinueWithCore(continuationFuture, scheduler, cancellationToken, continuationOptions);
return continuationFuture;
}
}
ContinueWith的核心是调用Task的ContinueWithCore方法，这里把我们的Action或Fun包装成子的Task，比如这里的ContinuationResultTaskFromResultTask实现【很是标准】如下：
internal sealed class ContinuationResultTaskFromResultTask<TAntecedentResult, TResult> : Task<TResult>
{
private Task<TAntecedentResult> m_antecedent;
public ContinuationResultTaskFromResultTask(
Task<TAntecedentResult> antecedent, Delegate function, object state, TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, ref StackCrawlMark stackMark) :
base(function, state, Task.InternalCurrentIfAttached(creationOptions), default(CancellationToken), creationOptions, internalOptions, null)
{
Contract.Requires(function is Func<Task<TAntecedentResult>, TResult> || function is Func<Task<TAntecedentResult>, object, TResult>, "Invalid delegate type in ContinuationResultTaskFromResultTask");
m_antecedent = antecedent;
PossiblyCaptureContext(ref stackMark);
} internal override void InnerInvoke()
{
var antecedent = m_antecedent;
Contract.Assert(antecedent != null, "No antecedent was set for the ContinuationResultTaskFromResultTask.");
m_antecedent = null;
antecedent.NotifyDebuggerOfWaitCompletionIfNecessary(); // Invoke the delegate
Contract.Assert(m_action != null);
var func = m_action as Func<Task<TAntecedentResult>, TResult>;
if (func != null)
{
m_result = func(antecedent);
return;
}
var funcWithState = m_action as Func<Task<TAntecedentResult>, object, TResult>;
if (funcWithState != null)
{
m_result = funcWithState(antecedent, m_stateObject);
return;
}
Contract.Assert(false, "Invalid m_action in ContinuationResultTaskFromResultTask");
}
}
ContinuationResultTaskFromResultTask<TAntecedentResult, TResult> 就重写基类Task的InnerInvoke方法，现在回到Task的ContinueWithCore方法：
public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable
{
/// Registers the continuation and possibly runs it (if the task is already finished).
internal void ContinueWithCore(Task continuationTask, TaskScheduler scheduler,CancellationToken cancellationToken, TaskContinuationOptions options)
{
Contract.Requires(continuationTask != null, "Task.ContinueWithCore(): null continuationTask");
Contract.Requires(scheduler != null, "Task.ContinueWithCore(): null scheduler");
Contract.Requires(!continuationTask.IsCompleted, "Did not expect continuationTask to be completed"); // Create a TaskContinuation
TaskContinuation continuation = new StandardTaskContinuation(continuationTask, options, scheduler); // If cancellationToken is cancellable, then assign it.
if (cancellationToken.CanBeCanceled)
{
if (IsCompleted || cancellationToken.IsCancellationRequested)
{
continuationTask.AssignCancellationToken(cancellationToken, null, null);
}
else
{
continuationTask.AssignCancellationToken(cancellationToken, this, continuation);
}
} // In the case of a pre-canceled token, continuationTask will have been completed
// in a Canceled state by now. If such is the case, there is no need to go through
// the motions of queuing up the continuation for eventual execution.
if (!continuationTask.IsCompleted)
{
if ((this.Options & (TaskCreationOptions)InternalTaskOptions.PromiseTask) != && !(this is ITaskCompletionAction))
{
var etwLog = TplEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.AwaitTaskContinuationScheduled(TaskScheduler.Current.Id, Task.CurrentId ?? , continuationTask.Id);
}
} // Attempt to enqueue the continuation
bool continuationQueued = AddTaskContinuation(continuation, addBeforeOthers: false); // If the continuation was not queued (because the task completed), then run it now.
if (!continuationQueued) continuation.Run(this, bCanInlineContinuationTask: true);
}
} private bool AddTaskContinuation(object tc, bool addBeforeOthers)
{
Contract.Requires(tc != null);
if (IsCompleted) return false; // Try to just jam tc into m_continuationObject
if ((m_continuationObject != null) || (Interlocked.CompareExchange(ref m_continuationObject, tc, null) != null))
{
return AddTaskContinuationComplex(tc, addBeforeOthers);
}
else return true;
} private bool AddTaskContinuationComplex(object tc, bool addBeforeOthers)
{
Contract.Requires(tc != null, "Expected non-null tc object in AddTaskContinuationComplex");
object oldValue = m_continuationObject;
// Logic for the case where we were previously storing a single continuation
if ((oldValue != s_taskCompletionSentinel) && (!(oldValue is List<object>)))
{
List<object> newList = new List<object>();
newList.Add(oldValue);
Interlocked.CompareExchange(ref m_continuationObject, newList, oldValue);
} // m_continuationObject is guaranteed at this point to be either a List or
// s_taskCompletionSentinel.
List<object> list = m_continuationObject as List<object>;
Contract.Assert((list != null) || (m_continuationObject == s_taskCompletionSentinel),"Expected m_continuationObject to be list or sentinel");
if (list != null)
{
lock (list)
{
if (m_continuationObject != s_taskCompletionSentinel)
{
// Before growing the list we remove possible null entries that are the
// result from RemoveContinuations()
if (list.Count == list.Capacity)
{
list.RemoveAll(s_IsTaskContinuationNullPredicate);
} if (addBeforeOthers)
list.Insert(0, tc);
else
list.Add(tc); return true; // continuation successfully queued, so return true.
}
}
}
// We didn't succeed in queuing the continuation, so return false.
return false;
} /// Handles everything needed for associating a CancellationToken with a task which is being constructed.
/// This method is meant to be be called either from the TaskConstructorCore or from ContinueWithCore
private void AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
{
ContingentProperties props = EnsureContingentPropertiesInitialized(needsProtection: false);
props.m_cancellationToken = cancellationToken; try
{
if (AppContextSwitches.ThrowExceptionIfDisposedCancellationTokenSource)
{
cancellationToken.ThrowIfSourceDisposed();
}
if ((((InternalTaskOptions)Options & (InternalTaskOptions.QueuedByRuntime | InternalTaskOptions.PromiseTask | InternalTaskOptions.LazyCancellation)) == ))
{
if (cancellationToken.IsCancellationRequested)
{
// Fast path for an already-canceled cancellationToken
this.InternalCancel(false);
}
else
{
// Regular path for an uncanceled cancellationToken
CancellationTokenRegistration ctr;
if (antecedent == null)
{
ctr = cancellationToken.InternalRegisterWithoutEC(s_taskCancelCallback, this);
}
else
{
ctr = cancellationToken.InternalRegisterWithoutEC(s_taskCancelCallback,new Tuple<Task, Task, TaskContinuation>(this, antecedent, continuation));
}
props.m_cancellationRegistration = new Shared<CancellationTokenRegistration>(ctr);
}
}
}
catch
{
if ((m_parent != null) &&((Options & TaskCreationOptions.AttachedToParent) != )&& ((m_parent.Options & TaskCreationOptions.DenyChildAttach) == ))
{
m_parent.DisregardChild();
}
throw;
}
} private readonly static Action<Object> s_taskCancelCallback = new Action<Object>(TaskCancelCallback);
private static void TaskCancelCallback(Object o)
{
var targetTask = o as Task;
if (targetTask == null)
{
var tuple = o as Tuple<Task, Task, TaskContinuation>;
if (tuple != null)
{
targetTask = tuple.Item1; Task antecedentTask = tuple.Item2;
TaskContinuation continuation = tuple.Item3;
antecedentTask.RemoveContinuation(continuation);
}
}
Contract.Assert(targetTask != null,"targetTask should have been non-null, with the supplied argument being a task or a tuple containing one");
targetTask.InternalCancel(false);
}
}
ContinueWithCore实现也比较简单，首先把当前的continuationTask转换为StandardTaskContinuation，然后把CancellationToken赋给continuationTask，如果continuationTask没有完成， 那么调用AddTaskContinuation把continuationTask加到等待对象中，如果AddTaskContinuation添加失败，就直接调用continuationTask。 让我妈来看看StandardTaskContinuation的实现：
internal abstract class TaskContinuation
{
internal abstract void Run(Task completedTask, bool bCanInlineContinuationTask); /// <summary>Tries to run the task on the current thread, if possible; otherwise, schedules it.</summary>
protected static void InlineIfPossibleOrElseQueue(Task task, bool needsProtection)
{
Contract.Requires(task != null);
Contract.Assert(task.m_taskScheduler != null);
if (needsProtection)
{
if (!task.MarkStarted())
return; // task has been previously started or canceled. Stop processing.
}
else
{
task.m_stateFlags |= Task.TASK_STATE_STARTED;
} // Try to inline it but queue if we can't
try
{
if (!task.m_taskScheduler.TryRunInline(task, taskWasPreviouslyQueued: false))
{
task.m_taskScheduler.InternalQueueTask(task);
}
}
catch (Exception e)
{ if (!(e is ThreadAbortException && (task.m_stateFlags & Task.TASK_STATE_THREAD_WAS_ABORTED) != )) // this ensures TAEs from QueueTask will be wrapped in TSE
{
TaskSchedulerException tse = new TaskSchedulerException(e);
task.AddException(tse);
task.Finish(false);
}
}
}
internal abstract Delegate[] GetDelegateContinuationsForDebugger();
} /// <summary>Provides the standard implementation of a task continuation.</summary>
internal class StandardTaskContinuation : TaskContinuation
{
internal readonly Task m_task;
internal readonly TaskContinuationOptions m_options;
private readonly TaskScheduler m_taskScheduler;
internal StandardTaskContinuation(Task task, TaskContinuationOptions options, TaskScheduler scheduler)
{
Contract.Requires(task != null, "TaskContinuation ctor: task is null");
Contract.Requires(scheduler != null, "TaskContinuation ctor: scheduler is null");
m_task = task;
m_options = options;
m_taskScheduler = scheduler;
if (AsyncCausalityTracer.LoggingOn)
AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, m_task.Id, "Task.ContinueWith: " + ((Delegate)task.m_action).Method.Name, ); if (Task.s_asyncDebuggingEnabled)
{
Task.AddToActiveTasks(m_task);
}
} /// <summary>Invokes the continuation for the target completion task.</summary>
/// <param name="completedTask">The completed task.</param>
/// <param name="bCanInlineContinuationTask">Whether the continuation can be inlined.</param>
internal override void Run(Task completedTask, bool bCanInlineContinuationTask)
{
Contract.Assert(completedTask != null);
Contract.Assert(completedTask.IsCompleted, "ContinuationTask.Run(): completedTask not completed"); // Check if the completion status of the task works with the desired
// activation criteria of the TaskContinuationOptions.
TaskContinuationOptions options = m_options;
bool isRightKind =
completedTask.IsRanToCompletion ?
(options & TaskContinuationOptions.NotOnRanToCompletion) == :
(completedTask.IsCanceled ?
(options & TaskContinuationOptions.NotOnCanceled) == :
(options & TaskContinuationOptions.NotOnFaulted) == ); // If the completion status is allowed, run the continuation.
Task continuationTask = m_task;
if (isRightKind)
{
if (!continuationTask.IsCanceled && AsyncCausalityTracer.LoggingOn)
{
// Log now that we are sure that this continuation is being ran
AsyncCausalityTracer.TraceOperationRelation(CausalityTraceLevel.Important, continuationTask.Id, CausalityRelation.AssignDelegate);
}
continuationTask.m_taskScheduler = m_taskScheduler; if (bCanInlineContinuationTask && // inlining is allowed by the caller
(options & TaskContinuationOptions.ExecuteSynchronously) != ) // synchronous execution was requested by the continuation's creator
{
InlineIfPossibleOrElseQueue(continuationTask, needsProtection: true);
}
else
{
try { continuationTask.ScheduleAndStart(needsProtection: true); }
catch (TaskSchedulerException)
{
// No further action is necessary -- ScheduleAndStart() already transitioned the
// task to faulted. But we want to make sure that no exception is thrown from here.
}
}
}
// Otherwise, the final state of this task does not match the desired
// continuation activation criteria; cancel it to denote this.
else continuationTask.InternalCancel(false);
}
internal override Delegate[] GetDelegateContinuationsForDebugger()
{
if (m_task.m_action == null)
{
return m_task.GetDelegateContinuationsForDebugger();
}
return new Delegate[] { m_task.m_action as Delegate };
}
}
StandardTaskContinuation的实现非常简单，而Task的AssignCancellationToken方法也没什么可以说的，只是需要注意下一下回调s_taskCancelCallback。Task的AddTaskContinuation方法首先检查当前Task是否结束，结束了就不用再调用AddTaskContinuationComplex方法了，直接调用continuation.Run方法，AddTaskContinuationComplex方法会把task添加到m_continuationObject中，最后FinishContinuations在调用m_continuationObject中的TaskContinuation.Run方法。
总结一下：ContinueWith方法主要调用ContinueWithCore方法，ContinueWithCore方法主要是调用AddTaskContinuation，AddTaskContinuation方法把Task加到m_continuationObject，【如果主的Task已经完成，那么这里AddTaskContinuation返回false，则直接调用TaskContinuation.Run】，当主的Task完成时会调用FinishContinuations方法，FinishContinuations方法会检测m_continuationObject中TaskContinuation对象，一次调用它们的Run方法。