public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable    {        [ThreadStatic]        internal static Task t_currentTask;  // The currently executing task.        [ThreadStatic]        private static StackGuard t_stackGuard;  // The stack guard object for this thread        internal static int s_taskIdCounter; //static counter used to generate unique task IDs        private readonly static TaskFactory s_factory = new TaskFactory();        private volatile int m_taskId; // this task‘s unique ID. initialized only if it is ever requested        internal object m_action;    // The body of the task.  Might be Action<object>, Action<TState> or Action.  Or possibly a Func.        // If m_action is set to null it will indicate that we operate in the        // "externally triggered completion" mode, which is exclusively meant         // for the signalling Task<TResult> (aka. promise). In this mode,        // we don‘t call InnerInvoke() in response to a Wait(), but simply wait on        // the completion event which will be set when the Future class calls Finish().        // But the event would now be signalled if Cancel() is called}

        internal object m_stateObject; // A state object that can be optionally supplied, passed to action.        internal TaskScheduler m_taskScheduler; // The task scheduler this task runs under.         internal readonly Task m_parent; // A task‘s parent, or null if parent-less.        internal volatile int m_stateFlags;

   public void Start()        {            Start(TaskScheduler.Current);        }public void Start(TaskScheduler scheduler)        {            // Read the volatile m_stateFlags field once and cache it for subsequent operations            int flags = m_stateFlags;            // Need to check this before (m_action == null) because completed tasks will            // set m_action to null.  We would want to know if this is the reason that m_action == null.            if (IsCompletedMethod(flags))            {                throw new InvalidOperationException(Environment.GetResourceString("Task_Start_TaskCompleted"));            }            if (scheduler == null)            {                throw new ArgumentNullException("scheduler");            }            var options = OptionsMethod(flags);            if ((options & (TaskCreationOptions)InternalTaskOptions.PromiseTask) != 0)            {                throw new InvalidOperationException(Environment.GetResourceString("Task_Start_Promise"));            }            if ((options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) != 0)            {                throw new InvalidOperationException(Environment.GetResourceString("Task_Start_ContinuationTask"));            }            // Make sure that Task only gets started once.  Or else throw an exception.            if (Interlocked.CompareExchange(ref m_taskScheduler, scheduler, null) != null)            {                throw new InvalidOperationException(Environment.GetResourceString("Task_Start_AlreadyStarted"));            }            ScheduleAndStart(true);        }

 public static TaskScheduler Current         {            get            {                TaskScheduler current = InternalCurrent;                return current ?? TaskScheduler.Default;            }        } internal static TaskScheduler InternalCurrent        {            get            {                Task currentTask = Task.InternalCurrent;                return ( (currentTask != null)                     && ((currentTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0)                    ) ? currentTask.ExecutingTaskScheduler : null;            }        }

public static TaskScheduler Default         {            get            {                return s_defaultTaskScheduler;            }        }   private static readonly TaskScheduler s_defaultTaskScheduler = new ThreadPoolTaskScheduler();