C# Task 是什么？返回值如何实现? Wait如何实现

public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state)
{
    StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
    Task currTask = Task.InternalCurrent;
    return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
        m_defaultCreationOptions, InternalTaskOptions.None, GetDefaultScheduler(currTask), ref stackMark);
}
private TaskScheduler GetDefaultScheduler(Task currTask)
{
    if (m_defaultScheduler != null) return m_defaultScheduler;
    else if ((currTask != null)&& ((currTask.CreationOptions & TaskCreationOptions.HideScheduler) == 0))
        return currTask.ExecutingTaskScheduler;
    else return TaskScheduler.Default;
}

public abstract class TaskScheduler
{
   private static readonly TaskScheduler s_defaultTaskScheduler = new ThreadPoolTaskScheduler();
    public static TaskScheduler Default 
    {
        get
        {
            return s_defaultTaskScheduler;
        }
    }
    internal void InternalQueueTask(Task task)
    {
        Contract.Requires(task != null);
        task.FireTaskScheduledIfNeeded(this);
        this.QueueTask(task);
    }
}

 public class Task<TResult> : Task
 {
   internal static Task<TResult> StartNew(Task parent, Func<object, TResult> function, object state, CancellationToken cancellationToken,
            TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark)
    {
        if (function == null)
        {
            throw new ArgumentNullException("function");
        }
        if (scheduler == null)
        {
            throw new ArgumentNullException("scheduler");
        }
        if ((internalOptions & InternalTaskOptions.SelfReplicating) != 0)
        {
            throw new ArgumentOutOfRangeException("creationOptions", Environment.GetResourceString("TaskT_ctor_SelfReplicating"));
        }

        // Create and schedule the future.
        Task<TResult> f = new Task<TResult>(function, state, parent, cancellationToken, creationOptions, internalOptions | InternalTaskOptions.QueuedByRuntime, scheduler, ref stackMark);

        f.ScheduleAndStart(false);
        return f;
    }
   internal void ScheduleAndStart(bool needsProtection)
    {
        Contract.Assert(m_taskScheduler != null, "expected a task scheduler to have been selected");
        Contract.Assert((m_stateFlags & TASK_STATE_STARTED) == 0, "task has already started");

        // Set the TASK_STATE_STARTED bit
        if (needsProtection)
        {
            if (!MarkStarted())
            {
                // A cancel has snuck in before we could get started.  Quietly exit.
                return;
            }
        }
        else
        {
            m_stateFlags |= TASK_STATE_STARTED;
        }

        if (s_asyncDebuggingEnabled)
        {
            AddToActiveTasks(this);
        }

        if (AsyncCausalityTracer.LoggingOn && (Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0)
        {
            //For all other task than TaskContinuations we want to log. TaskContinuations log in their constructor
            AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, this.Id, "Task: "+((Delegate)m_action).Method.Name, 0);
        }
        try
        {
            m_taskScheduler.InternalQueueTask(this);
        }
        catch (ThreadAbortException tae)
        {
            AddException(tae);
            FinishThreadAbortedTask(true, false);
        }
        catch (Exception e)
        {
            TaskSchedulerException tse = new TaskSchedulerException(e);
            AddException(tse);
            Finish(false);
            if ((Options & (TaskCreationOptions)InternalTaskOptions.ContinuationTask) == 0)
            {
                // m_contingentProperties.m_exceptionsHolder *should* already exist after AddException()
                Contract.Assert(
                    (m_contingentProperties != null) &&
                    (m_contingentProperties.m_exceptionsHolder != null) &&
                    (m_contingentProperties.m_exceptionsHolder.ContainsFaultList),
                        "Task.ScheduleAndStart(): Expected m_contingentProperties.m_exceptionsHolder to exist " +
                        "and to have faults recorded.");

                m_contingentProperties.m_exceptionsHolder.MarkAsHandled(false);
            }
            // re-throw the exception wrapped as a TaskSchedulerException.
            throw tse;
        }
    }
  
        
  internal Task(
        Func<object, TResult> valueSelector, object state, Task parent, CancellationToken cancellationToken,
        TaskCreationOptions creationOptions, InternalTaskOptions internalOptions, TaskScheduler scheduler, ref StackCrawlMark stackMark) :
        this(valueSelector, state, parent, cancellationToken, creationOptions, internalOptions, scheduler)
    {
        PossiblyCaptureContext(ref stackMark);
    }
    internal void PossiblyCaptureContext(ref StackCrawlMark stackMark)
    {
        Contract.Assert(m_contingentProperties == null || m_contingentProperties.m_capturedContext == null, "Captured an ExecutionContext when one was already captured.");
        CapturedContext = ExecutionContext.Capture(ref stackMark, ExecutionContext.CaptureOptions.IgnoreSyncCtx | ExecutionContext.CaptureOptions.OptimizeDefaultCase);
    }
    internal override void InnerInvoke()
    {
        // Invoke the delegate
        Contract.Assert(m_action != null);
        var func = m_action as Func<TResult>;
        if (func != null)
        {
            m_result = func();
            return;
        }
        var funcWithState = m_action as Func<object, TResult>;
        if (funcWithState != null)
        {
            m_result = funcWithState(m_stateObject);
            return;
        }
        Contract.Assert(false, "Invalid m_action in Task<TResult>");
    }

    public TResult Result
    {
        get { return IsWaitNotificationEnabledOrNotRanToCompletion ? GetResultCore(waitCompletionNotification: true) : m_result; }
    }
   
 }

internal sealed class ThreadPoolTaskScheduler: TaskScheduler
{
   private static readonly ParameterizedThreadStart s_longRunningThreadWork = new ParameterizedThreadStart(LongRunningThreadWork);

    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 internal override void QueueTask(Task task)
    {
        if ((task.Options & TaskCreationOptions.LongRunning) != 0)
        {
            // Run LongRunning tasks on their own dedicated thread.
            Thread thread = new Thread(s_longRunningThreadWork);
            thread.IsBackground = true; // Keep this thread from blocking process shutdown
            thread.Start(task);
        }
        else
        {
            // Normal handling for non-LongRunning tasks.
            bool forceToGlobalQueue = ((task.Options & TaskCreationOptions.PreferFairness) != 0);
            ThreadPool.UnsafeQueueCustomWorkItem(task, forceToGlobalQueue);
        }
    }
}

public class Task : IThreadPoolWorkItem, IAsyncResult, IDisposable
{
    [ThreadStatic]
    internal static Task t_currentTask;