protected internal override void QueueTask(Task task)
{
#if !FEATURE_PAL && !FEATURE_CORECLR // PAL and CoreClr don't support eventing
var etwLog = TplEtwProvider.Log;
if (etwLog.IsEnabled(EventLevel.Verbose, ((EventKeywords)(-1))))
{
Task currentTask = Task.InternalCurrent;
Task creatingTask = task.m_parent;
etwLog.TaskScheduled(this.Id, currentTask == null ? 0 : currentTask.Id,
task.Id, creatingTask == null ? 0 : creatingTask.Id,
(int)task.Options);
}
#endif
if ((task.Options & TaskCreationOptions.LongRunning) != 0)
{
NativeThreadPool.QueueLongRunningWork(() => task.ExecuteEntry(false));
}
else
{
// Normal handling for non-LongRunning tasks.
bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0);
ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue);
}
}
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 bool TryExecuteTask(Task task)
{
if (task.Scheduler != this)
{
throw new InvalidOperationException("Wrong Task Scheduler");
}
return(task.ExecuteEntry(true));
}
protected bool TryExecuteTask(Task task)
{
if (task.ExecutingTaskScheduler != this)
{
throw new InvalidOperationException(Environment.GetResourceString("TaskScheduler_ExecuteTask_WrongTaskScheduler"));
}
return(task.ExecuteEntry(true));
}
/// <summary>
/// Attempts to execute the provided <see cref="System.Threading.Tasks.Task">Task</see>
/// on this scheduler.
/// </summary>
/// <remarks>
/// <para>
/// Scheduler implementations are provided with <see cref="System.Threading.Tasks.Task">Task</see>
/// instances to be executed through either the <see cref="QueueTask"/> method or the
/// <see cref="TryExecuteTaskInline"/> method. When the scheduler deems it appropriate to run the
/// provided task, <see cref="TryExecuteTask"/> should be used to do so. TryExecuteTask handles all
/// aspects of executing a task, including action invocation, exception handling, state management,
/// and lifecycle control.
/// </para>
/// <para>
/// <see cref="TryExecuteTask"/> must only be used for tasks provided to this scheduler by the .NET
/// Framework infrastructure. It should not be used to execute arbitrary tasks obtained through
/// custom mechanisms.
/// </para>
/// </remarks>
/// <param name="task">
/// A <see cref="System.Threading.Tasks.Task">Task</see> object to be executed.</param>
/// <exception cref="System.InvalidOperationException">
/// The <paramref name="task"/> is not associated with this scheduler.
/// </exception>
/// <returns>A Boolean that is true if <paramref name="task"/> was successfully executed, false if it
/// was not. A common reason for execution failure is that the task had previously been executed or
/// is in the process of being executed by another thread.</returns>
protected bool TryExecuteTask(Task task)
{
if (task.ExecutingTaskScheduler != this)
{
throw new InvalidOperationException(SR.TaskScheduler_ExecuteTask_WrongTaskScheduler);
}
return(task.ExecuteEntry());
}
protected bool TryExecuteTask(Task task)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (task.ExecutingTaskScheduler != this)
{
throw new InvalidOperationException("Wrong Task Scheduler");
}
return(task.ExecuteEntry(true));
}
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem((IThreadPoolWorkItem)task))
{
return(false);
}
try
{
return(task.ExecuteEntry(false));
}
finally
{
if (taskWasPreviouslyQueued)
{
this.NotifyWorkItemProgress();
}
}
}
/// <summary>
/// This internal function will do this:
/// (1) If the task had previously been queued, attempt to pop it and return false if that fails.
/// (2) Propagate the return value from Task.ExecuteEntry() back to the caller.
///
/// IMPORTANT NOTE: TryExecuteTaskInline will NOT throw task exceptions itself. Any wait code path using this function needs
/// to account for exceptions that need to be propagated, and throw themselves accordingly.
/// </summary>
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
// If the task was previously scheduled, and we can't pop it, then return false.
if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task))
return false;
// Propagate the return value of Task.ExecuteEntry()
bool rval = false;
try
{
rval = task.ExecuteEntry(false); // handles switching Task.Current etc.
}
finally
{
// Only call NWIP() if task was previously queued
if(taskWasPreviouslyQueued) NotifyWorkItemProgress();
}
return rval;
}
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task))
{
return false;
}
bool flag = false;
try
{
flag = task.ExecuteEntry(false);
}
finally
{
if (taskWasPreviouslyQueued)
{
this.NotifyWorkItemProgress();
}
}
return flag;
}
/// <summary>
/// Schedules a task to the ThreadPool.
/// </summary>
/// <param name="task">The task to schedule.</param>
protected internal override void QueueTask(Task task)
{
if (TaskTrace.Enabled)
{
Task currentTask = Task.InternalCurrent;
Task creatingTask = task.m_parent;
TaskTrace.TaskScheduled(this.Id, currentTask == null ? 0 : currentTask.Id,
task.Id, creatingTask == null ? 0 : creatingTask.Id,
(int)task.Options);
}
if ((task.Options & TaskCreationOptions.LongRunning) != 0)
{
ThreadPool.QueueLongRunningWork(() => task.ExecuteEntry(false));
}
else
{
// Normal handling for non-LongRunning tasks.
bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0);
ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue);
}
}
/// <summary>
/// Schedules a task to the ThreadPool.
/// </summary>
/// <param name="task">The task to schedule.</param>
protected internal override void QueueTask(Task task)
{
if (TaskTrace.Enabled)
{
Task currentTask = Task.InternalCurrent;
Task creatingTask = task.m_parent;
TaskTrace.TaskScheduled(this.Id, currentTask == null ? 0 : currentTask.Id,
task.Id, creatingTask == null ? 0 : creatingTask.Id,
(int)task.Options);
}
if ((task.Options & TaskCreationOptions.LongRunning) != 0)
{
ThreadPool.QueueLongRunningWork(() => task.ExecuteEntry(false));
}
else
{
// Normal handling for non-LongRunning tasks.
bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0);
ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue);
}
}
protected bool TryExecuteTask(Task task)
{
if (task.ExecutingTaskScheduler != this)
{
throw new InvalidOperationException(Environment.GetResourceString("TaskScheduler_ExecuteTask_WrongTaskScheduler"));
}
return task.ExecuteEntry(true);
}
protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
// If the task was previously scheduled, and we can't pop it, then return false.
#if !PFX_LEGACY_3_5
if (taskWasPreviouslyQueued && !ThreadPool.TryPopCustomWorkItem(task))
{
return false;
}
#endif
// Propagate the return value of Task.ExecuteEntry()
bool rval = false;
try
{
#if PFX_LEGACY_3_5
// 3.5 needs atomic state transitions
rval = task.ExecuteEntry(true); // calling the TaskBase override here, because it handles switching Task.Current etc.
#else
rval = task.ExecuteEntry(false); // calling the TaskBase override here, because it handles switching Task.Current etc.
#endif
}
finally
{
// Only call NWIP() if task was previously queued
if(taskWasPreviouslyQueued) NotifyWorkItemProgress();
}
return rval;
}
protected internal override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
{
if ((task.CreationOptions & TaskCreationOptions.LongRunning) != 0)
{
// LongRunning task are going to run on a dedicated Thread.
return false;
}
// Propagate the return value of Task.ExecuteEntry()
bool result;
try
{
result = task.ExecuteEntry(true); // handles switching Task.Current etc.
}
finally
{
// Only call NWIP() if task was previously queued
if (taskWasPreviouslyQueued) NotifyWorkItemProgress();
}
return result;
}
static void TaskExecuteWaitCallback(Object obj)
{
Task task = (Task)obj;
task.ExecuteEntry(true);
}
// Token: 0x06004105 RID: 16645 RVA: 0x000F1B80 File Offset: 0x000EFD80
private static void LongRunningThreadWork(object obj)
{
Task task = obj as Task;
task.ExecuteEntry(false);
}
protected bool TryExecuteTask(Task task)
{
if (task.ExecutingTaskScheduler != this)
{
throw new InvalidOperationException(SR.TaskScheduler_ExecuteTask_WrongTaskScheduler);
}
return task.ExecuteEntry(true);
}
// Token: 0x060040FE RID: 16638 RVA: 0x000F1B0C File Offset: 0x000EFD0C
private static void PostCallback(object obj)
{
Task task = (Task)obj;
task.ExecuteEntry(true);
}
