// Token: 0x06004053 RID: 16467 RVA: 0x000EFBD4 File Offset: 0x000EDDD4
internal override void Run(Task completedTask, bool bCanInlineContinuationTask)
{
TaskContinuationOptions options = this.m_options;
bool flag = completedTask.IsRanToCompletion ? ((options & TaskContinuationOptions.NotOnRanToCompletion) == TaskContinuationOptions.None) : (completedTask.IsCanceled ? ((options & TaskContinuationOptions.NotOnCanceled) == TaskContinuationOptions.None) : ((options & TaskContinuationOptions.NotOnFaulted) == TaskContinuationOptions.None));
Task task = this.m_task;
if (flag)
{
if (!task.IsCanceled && AsyncCausalityTracer.LoggingOn)
{
AsyncCausalityTracer.TraceOperationRelation(CausalityTraceLevel.Important, task.Id, CausalityRelation.AssignDelegate);
}
task.m_taskScheduler = this.m_taskScheduler;
if (bCanInlineContinuationTask && (options & TaskContinuationOptions.ExecuteSynchronously) != TaskContinuationOptions.None)
{
TaskContinuation.InlineIfPossibleOrElseQueue(task, true);
return;
}
try
{
task.ScheduleAndStart(true);
return;
}
catch (TaskSchedulerException)
{
return;
}
}
task.InternalCancel(false);
}
// Token: 0x0600405C RID: 16476 RVA: 0x000EFE3C File Offset: 0x000EE03C
internal sealed override void Run(Task ignored, bool canInlineContinuationTask)
{
if (this.m_scheduler == TaskScheduler.Default)
{
base.Run(ignored, canInlineContinuationTask);
return;
}
bool flag = canInlineContinuationTask && (TaskScheduler.InternalCurrent == this.m_scheduler || Thread.CurrentThread.IsThreadPoolThread);
Task task = base.CreateTask(delegate(object state)
{
try
{
((Action)state)();
}
catch (Exception exc)
{
AwaitTaskContinuation.ThrowAsyncIfNecessary(exc);
}
}, this.m_action, this.m_scheduler);
if (flag)
{
TaskContinuation.InlineIfPossibleOrElseQueue(task, false);
return;
}
try
{
task.ScheduleAndStart(false);
}
catch (TaskSchedulerException)
{
}
}
public static void Rooter()
{
Task t = null;
t.GetDelegateContinuationsForDebugger();
TaskContinuation tc = null;
tc.GetDelegateContinuationsForDebugger();
AsyncMethodBuilderCore.TryGetStateMachineForDebugger(null);
Task.GetActiveTaskFromId(0);
return;
}
internal override sealed void Run(Task ignored, bool canInlineContinuationTask)
{
if (this.m_scheduler == TaskScheduler.Default)
{
base.Run(ignored, canInlineContinuationTask);
}
else
{
int num = !canInlineContinuationTask ? 0 : (TaskScheduler.InternalCurrent == this.m_scheduler ? 1 : (Thread.CurrentThread.IsThreadPoolThread ? 1 : 0));
Task task = this.CreateTask((Action <object>)(state =>
{
try
{
((Action)state)();
}
catch (Exception ex)
{
AwaitTaskContinuation.ThrowAsyncIfNecessary(ex);
}
}), (object)this.m_action, this.m_scheduler);
if (num != 0)
{
TaskContinuation.InlineIfPossibleOrElseQueue(task, false);
}
else
{
try
{
task.ScheduleAndStart(false);
}
catch (TaskSchedulerException ex)
{
}
}
}
}
private void AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
{
CancellationToken = cancellationToken;
try
{
cancellationToken.ThrowIfSourceDisposed();
// If an unstarted task has a valid CancellationToken that gets signalled while the task is still not queued
// we need to proactively cancel it, because it may never execute to transition itself.
// The only way to accomplish this is to register a callback on the CT.
// We exclude Promise tasks from this, because TaskCompletionSource needs to fully control the inner tasks's lifetime (i.e. not allow external cancellations)
if ((_internalOptions & (InternalTaskOptions.QueuedByRuntime | InternalTaskOptions.PromiseTask | InternalTaskOptions.LazyCancellation)) == 0)
{
if (cancellationToken.IsCancellationRequested)
{
// Fast path for an already-canceled cancellationToken
InternalCancel(false);
}
else
{
// Regular path for an uncanceled cancellationToken
CancellationTokenRegistration registration;
if (antecedent == null)
{
// if no antecedent was specified, use this task's reference as the cancellation state object
registration = cancellationToken.Register(_taskCancelCallback, this);
}
else
{
// If an antecedent was specified, pack this task, its antecedent and the TaskContinuation together as a tuple
// and use it as the cancellation state object. This will be unpacked in the cancellation callback so that
// antecedent.RemoveCancellation(continuation) can be invoked.
registration = cancellationToken.Register(_taskCancelCallback, new Tuple <Task, Task, TaskContinuation>(this, antecedent, continuation));
}
_cancellationRegistration = new StrongBox <CancellationTokenRegistration>(registration);
}
}
}
catch (Exception)
{
// If we have an exception related to our CancellationToken, then we need to subtract ourselves
// from our parent before throwing it.
if (_parent != null &&
(CreationOptions & TaskCreationOptions.AttachedToParent) != 0 &&
(_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0
)
{
_parent.DisregardChild();
}
throw;
}
}
private void AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
{
CancellationToken = cancellationToken;
try
{
GC.KeepAlive(cancellationToken.WaitHandle);
// If an unstarted task has a valid CancellationToken that gets signalled while the task is still not queued
// we need to proactively cancel it, because it may never execute to transition itself.
// The only way to accomplish this is to register a callback on the CT.
// We exclude Promise tasks from this, because TaskCompletionSource needs to fully control the inner tasks's lifetime (i.e. not allow external cancellations)
if ((_internalOptions & (InternalTaskOptions.QueuedByRuntime | InternalTaskOptions.PromiseTask | InternalTaskOptions.LazyCancellation)) != 0)
{
return;
}
if (cancellationToken.IsCancellationRequested)
{
// Fast path for an already-canceled cancellationToken
InternalCancel(false);
}
else
{
// Regular path for an uncanceled cancellationToken
var registration = cancellationToken.Register(_taskCancelCallback, antecedent == null ? (object)this : new Tuple <Task, Task, TaskContinuation>(this, antecedent, continuation));
_cancellationRegistration = new StrongBox <CancellationTokenRegistration>(registration);
}
}
catch (Exception)
{
// If we have an exception related to our CancellationToken, then we need to subtract ourselves
// from our parent before throwing it.
if (_parent != null &&
(CreationOptions & TaskCreationOptions.AttachedToParent) != 0 &&
(_parent.CreationOptions & TaskCreationOptions.DenyChildAttach) == 0
)
{
_parent.DisregardChild();
}
throw;
}
}
private void AssignCancellationToken(CancellationToken cancellationToken, Task antecedent, TaskContinuation continuation)
{
CancellationToken = cancellationToken;
try
{
cancellationToken.ThrowIfSourceDisposed();
// If an unstarted task has a valid CancellationToken that gets signalled while the task is still not queued
// we need to proactively cancel it, because it may never execute to transition itself.
// The only way to accomplish this is to register a callback on the CT.
// We exclude Promise tasks from this, because TaskCompletionSource needs to fully control the inner tasks's lifetime (i.e. not allow external cancellations)
if ((_internalOptions & (InternalTaskOptions.QueuedByRuntime | InternalTaskOptions.PromiseTask | InternalTaskOptions.LazyCancellation)) == 0)
{
if (cancellationToken.IsCancellationRequested)
{
// Fast path for an already-canceled cancellationToken
InternalCancel(false);
}
else
{
// Regular path for an uncanceled cancellationToken
CancellationTokenRegistration registration;
if (antecedent == null)
{
// if no antecedent was specified, use this task's reference as the cancellation state object
registration = cancellationToken.Register(_taskCancelCallback, this);
}
else
{
// If an antecedent was specified, pack this task, its antecedent and the TaskContinuation together as a tuple
// and use it as the cancellation state object. This will be unpacked in the cancellation callback so that
// antecedent.RemoveCancellation(continuation) can be invoked.
registration = cancellationToken.Register(_taskCancelCallback, new Tuple<Task, Task, TaskContinuation>(this, antecedent, continuation));
}
_cancellationRegistration = new StrongBox<CancellationTokenRegistration>(registration);
}
}
}
catch (Exception)
{
// If we have an exception related to our CancellationToken, then we need to subtract ourselves
// from our parent before throwing it.
if ((_parent != null)
&& ((_creationOptions & TaskCreationOptions.AttachedToParent) != 0)
&& ((_parent._creationOptions & TaskCreationOptions.DenyChildAttach) == 0)
)
{
_parent.DisregardChild();
}
throw;
}
}
