using System;

using System.Collections.Generic;

using System.Threading;

using System.Threading.Tasks;

​

public class Program {

    public static async Task Main() {

        var scheduler = new SerialScheduler();

        PrintSchedulerStatus("Outside");

        await Task.Factory.StartNew(async () => {

            PrintSchedulerStatus("Parent");

            await Task.Run(() => PrintSchedulerStatus("Child"))

                .ConfigureAwait(true);

            Console.WriteLine("continueOnCapturedContext=true");

            PrintSchedulerStatus("Parent");

            await Task.Factory.StartNew(() => PrintSchedulerStatus("Child"))

                .ConfigureAwait(false);

            Console.WriteLine("continueOnCapturedContext=false");

            PrintSchedulerStatus("Parent");

            await Task.Factory.StartNew(() => PrintSchedulerStatus("Child"), default, default, scheduler)

                .ConfigureAwait(false);

            Console.WriteLine("continueOnCapturedContext=false");

            PrintSchedulerStatus("Parent");

        }, default, default, scheduler).Unwrap();

        PrintSchedulerStatus("Outside");

    }

    static void PrintSchedulerStatus(string label) {

        Console.WriteLine(" {0,7} {1}", label, TaskScheduler.Current == TaskScheduler.Default ? "Default" : "Custom");

    }

}

​

public class SerialScheduler : TaskScheduler {

    // Indicates whether the current thread is processing work items.

    [ThreadStatic]

    private static bool _currentThreadIsProcessingItems;

​

    // The list of tasks to be executed

    private readonly LinkedList<Task> _tasks = new LinkedList<Task>(); // protected by lock(_tasks)

​

    // Queues a task to the scheduler.

    protected sealed override void QueueTask(Task task) {

        lock (_tasks) {

            _tasks.AddLast(task);

            NotifyThreadPoolOfPendingWork();

        }

    }

​

    // Inform the ThreadPool that there's work to be executed for this scheduler.

    private void NotifyThreadPoolOfPendingWork() {

        ThreadPool.UnsafeQueueUserWorkItem(_ => {

            // Note that the current thread is now processing work items.

            // This is necessary to enable inlining of tasks into this thread.

            _currentThreadIsProcessingItems = true;

            try {

                // Process all available items in the queue.

                while (true) {

                    Task item;

                    lock (_tasks) {

                        // When there are no more items to be processed,

                        // note that we're done processing, and get out.

                        if (_tasks.Count == 0) {

                            break;

                        }

​

                        // Get the next item from the queue

                        item = _tasks.First.Value;

                        _tasks.RemoveFirst();

                    }

​

                    // Execute the task we pulled out of the queue

                    base.TryExecuteTask(item);

                }

            }

            finally {

                // We're done processing items on the current thread

                _currentThreadIsProcessingItems = false;

            }

        }, null);

    }

​

    // Attempts to execute the specified task on the current thread.

    protected sealed override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued) {

        // If this thread isn't already processing a task, we don't support inlining

        if (!_currentThreadIsProcessingItems) {

            return false;

        }

​

        // If the task was previously queued, remove it from the queue

        if (taskWasPreviouslyQueued) {

            // Try to run the task.

            return TryDequeue(task) && base.TryExecuteTask(task);

        }

        else {

            return base.TryExecuteTask(task);

        }

    }

​

    // Attempt to remove a previously scheduled task from the scheduler.

    protected sealed override bool TryDequeue(Task task) {

        lock (_tasks) {

            return _tasks.Remove(task);

        }

    }

​

    // Gets an enumerable of the tasks currently scheduled on this scheduler.

    protected sealed override IEnumerable<Task> GetScheduledTasks() {

        bool lockTaken = false;

        try {

            Monitor.TryEnter(_tasks, ref lockTaken);

            if (lockTaken) {

                return _tasks;

            }

            else {

                throw new NotSupportedException();

            }

        }

        finally {

            if (lockTaken) {

                Monitor.Exit(_tasks);

            }

        }

    }

}

​