using System;
using System.Threading.Tasks;
class Program
{
    static void Main()
    {
        var cesp = new ConcurrentExclusiveSchedulerPair();
        Task.Factory.StartNew(() =>
        {
            Console.WriteLine(TaskScheduler.Current == cesp.ExclusiveScheduler);
        }, default, TaskCreationOptions.None, cesp.ExclusiveScheduler)
        .Wait();
    }
}

public abstract class TaskScheduler
{
    // 任務入口，待調(diào)度執(zhí)行的 Task 會通過該方法傳入，調(diào)度器會將任務安排task到指定的隊列（線程池任務隊列（全局任務隊列、本地隊列）、獨立線程、ui線程） 只能被.NET Framework調(diào)用，不能配派生類調(diào)用
   //
    protected internal abstract void QueueTask(Task task);
    // 這個是在執(zhí)行 Task 回調(diào)的時候才會被執(zhí)行到的方法，放到后面再講
    protected abstract bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued);

protected abstract bool TryExecuteTask(Task task, bool taskWasPreviouslyQueued);

// 獲取所有調(diào)度到該 TaskScheduler 的 Task
 protected abstract IEnumerable<Task>? GetScheduledTasks();
 }

internal sealed class ThreadPoolTaskScheduler : TaskScheduler
    {
//其他代碼
   protected internal override void QueueTask(Task task)
        {
            TaskCreationOptions options = task.Options;
            if (Thread.IsThreadStartSupported && (options & TaskCreationOptions.LongRunning) != 0)
            {
                // Run LongRunning tasks on their own dedicated thread.
                new Thread(s_longRunningThreadWork)
                {
                    IsBackground = true,
                    Name = ".NET Long Running Task"
                }.UnsafeStart(task);
            }
            else
            {
                // Normal handling for non-LongRunning tasks.
                ThreadPool.UnsafeQueueUserWorkItemInternal(task, (options & TaskCreationOptions.PreferFairness) == 0);
            }
        }
//其他代碼
 }

internal sealed class SynchronizationContextTaskScheduler : TaskScheduler
    {
//初始化時候 ，捕獲當前線程的同步上下文  
 internal SynchronizationContextTaskScheduler()
        {
            m_synchronizationContext = SynchronizationContext.Current ??
                // make sure we have a synccontext to work with
                throw new InvalidOperationException(SR.TaskScheduler_FromCurrentSynchronizationContext_NoCurrent);
        }
//其他代碼
private readonly SynchronizationContext m_synchronizationContext;
protected internal override void QueueTask(Task task)
        {
            m_synchronizationContext.Post(s_postCallback, (object)task);
        }
//其他代碼
///改變post的調(diào)度方法、 調(diào)用者線程執(zhí)行各方面的任務操作
  private static readonly SendOrPostCallback s_postCallback = static s =>
        {
            Debug.Assert(s is Task);
            ((Task)s).ExecuteEntry(); //調(diào)用者線程執(zhí)行各方面的任務操作
        };
 }

public partial class SynchronizationContext
    {
　　　　//其他代碼
　　　　public virtual void Post(SendOrPostCallback d, object? state) => ThreadPool.QueueUserWorkItem(static s => s.d(s.state), (d, state), preferLocal: false);
　　 //其他代碼
　　}

private void button1_Click(object sender, EventArgs e)
         {
             Task task = Task.Factory.StartNew(() =>
             {
                 //復雜操作，等待10s
                 Thread.Sleep(10000);
             }).ContinueWith((t) =>
             {
                 button1.Text = "hello world";
             }, TaskScheduler.FromCurrentSynchronizationContext());
         }

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var task = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("hello world?。。?);
            }, new CancellationToken(), TaskCreationOptions.None, new PerThreadTaskScheduler());
            Console.Read();
        }
    }
    /// <summary>
    /// 每個Task一個Thread
    /// </summary>
    public class PerThreadTaskScheduler : TaskScheduler
    {
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            return null;
        }
        protected override void QueueTask(Task task)
        {
            var thread = new Thread(() =>
            {
                TryExecuteTask(task);
            });
            thread.Start();
        }
        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            throw new NotImplementedException();
        }
    }
}

System.InvalidOperationException: 'The calling thread cannot access this object because a different thread owns it.'

private static readonly HttpClient s_httpClient = new HttpClient();
private void downloadBtn_Click(object sender, RoutedEventArgs e)
{
    s_httpClient.GetStringAsync("http://example.com/currenttime").ContinueWith(downloadTask =>
    {
        downloadBtn.Content = downloadTask.Result;
    }, TaskScheduler.FromCurrentSynchronizationContext());//捕獲當前UI線程的同步上下文
}