C# Task.FireTaskScheduledIfNeeded方法代码示例

        internal bool TryRunInline(Task task, bool taskWasPreviouslyQueued)
        {
            // Do not inline unstarted tasks (i.e., task.ExecutingTaskScheduler == null).
            // Do not inline TaskCompletionSource-style (a.k.a. "promise") tasks.
            // No need to attempt inlining if the task body was already run (i.e. either TASK_STATE_DELEGATE_INVOKED or TASK_STATE_CANCELED bits set)
            TaskScheduler ets = task.ExecutingTaskScheduler;
            
            // Delegate cross-scheduler inlining requests to target scheduler
            if(ets != this && ets !=null) return ets.TryRunInline(task, taskWasPreviouslyQueued);

            StackGuard currentStackGuard;
            if( (ets == null) ||
                (task.m_action == null) ||
                task.IsDelegateInvoked || 
                task.IsCanceled ||
                (currentStackGuard = Task.CurrentStackGuard).TryBeginInliningScope() == false)
            {
                return false;
            }

            // Task class will still call into TaskScheduler.TryRunInline rather than TryExecuteTaskInline() so that 
            // 1) we can adjust the return code from TryExecuteTaskInline in case a buggy custom scheduler lies to us
            // 2) we maintain a mechanism for the TLS lookup optimization that we used to have for the ConcRT scheduler (will potentially introduce the same for TP)
            bool bInlined = false;
            try
            {
                task.FireTaskScheduledIfNeeded(this);
                bInlined = TryExecuteTaskInline(task, taskWasPreviouslyQueued);
            }
            finally
            {
                currentStackGuard.EndInliningScope();
            }

            // If the custom scheduler returned true, we should either have the TASK_STATE_DELEGATE_INVOKED or TASK_STATE_CANCELED bit set
            // Otherwise the scheduler is buggy
            if (bInlined && !(task.IsDelegateInvoked || task.IsCanceled)) 
            {
                throw new InvalidOperationException(Environment.GetResourceString("TaskScheduler_InconsistentStateAfterTryExecuteTaskInline"));
            }

            return bInlined;
        }

        internal void InternalQueueTask(Task task)
        {
            Contract.Requires(task != null);

            task.FireTaskScheduledIfNeeded(this);

            this.QueueTask(task);
        }

        internal void InternalQueueTask(Task task)
        {
            Contract.Requires(task != null);

#if !FEATURE_PAL && !FEATURE_CORECLR
            task.FireTaskScheduledIfNeeded(this);
#endif
            this.QueueTask(task);
        }