using System;

using System.Collections.Generic;

using System.Collections.Concurrent;

using System.Linq;

using System.Threading;

using System.Threading.Tasks;

public class Program

{

    public async static Task Main()

    {

        var scheduler = new SingleThreadTaskScheduler(default);

        var tasks = Enumerable.Range(0, 100).Select(i => 

            Task.Factory.StartNew(

                DoSomething,

                i,

                CancellationToken.None,

                TaskCreationOptions.DenyChildAttach,

                scheduler)

        );

        var threadIds = await Task.WhenAll(tasks);

        Console.WriteLine($"There were {threadIds.Distinct().Count()} different threads involved.");

    }

    static int DoSomething(object obj)

    {

        int threadId = Thread.CurrentThread.ManagedThreadId;

        //Console.WriteLine($"{(int)obj}: {threadId}");

        return threadId;

    }

}

​

   public sealed class SingleThreadTaskScheduler : TaskScheduler

    {

        [ThreadStatic]

        private static bool _isExecuting;

​

        private readonly CancellationToken _cancellationToken;

​

        private readonly BlockingCollection<Task> _taskQueue;

​

        private readonly Lazy<Thread> _singleThread;

        public override int MaximumConcurrencyLevel => 1;

​

        public SingleThreadTaskScheduler(CancellationToken cancellationToken)

        {

            this._cancellationToken = cancellationToken;

            this._taskQueue = new BlockingCollection<Task>();

            _singleThread = new Lazy<Thread>(() =>

                {

                    var thread = new Thread(RunOnCurrentThread) { Name = "STTS Thread", IsBackground = true };

                    thread.Start();

                    return thread;

                }

            );

        }

​

        private void RunOnCurrentThread()

        {

            _isExecuting = true;

​

            try

            {

                foreach (var task in _taskQueue.GetConsumingEnumerable(_cancellationToken))

                {

                    TryExecuteTask(task);

                }

            }

            catch (OperationCanceledException)

            { }

            finally

            {

                _isExecuting = false;

            }

        }

​

        protected override IEnumerable<Task> GetScheduledTasks() => _taskQueue.ToList();

​

        protected override void QueueTask(Task task)

        {

            _ = _singleThread.Value;

            try

            {

                _taskQueue.Add(task, _cancellationToken);

            }

            catch (OperationCanceledException)

            { }

        }

​

        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)

        {

            // We'd need to remove the task from queue if it was already queued. 

            // That would be too hard.

            if (taskWasPreviouslyQueued) return false;

​

            return _isExecuting && TryExecuteTask(task);

        }

    }