What is a TaskScheduler, and what is the difference between TaskScheduler.Default and TaskScheduler.Current?

1. How Current is determined

public static TaskScheduler Current
{
    get
    {
        Task? current = Task.InternalCurrent;     // the task executing on this thread, if any
        if (current != null && (current.CreationOptions & TaskCreationOptions.HideScheduler) == 0)
            return current.ExecutingTaskScheduler ?? Default;
        return Default;
    }
}

It's a property of the currently executing task, not of the thread. Outside of any task (e.g. in an ASP.NET Core request after an await resumed on the pool), it's Default.

2. Task.Run vs StartNew options

Correct explicit StartNew:

Task.Factory.StartNew(work, ct, TaskCreationOptions.DenyChildAttach | TaskCreationOptions.LongRunning, TaskScheduler.Default);

3. Inlining

If a thread calls Wait() on a task that hasn't started and its scheduler allows inlining, the scheduler may run it right there (TryExecuteTaskInline). This avoids a thread hop but means the task runs on the waiting thread, possibly while that thread holds locks, which can surprise code that assumed a different thread.

4. ConcurrentExclusiveSchedulerPair with async code

var pair = new ConcurrentExclusiveSchedulerPair(TaskScheduler.Default, maxConcurrencyLevel: 4);
var exclusive = new TaskFactory(pair.ExclusiveScheduler);

await exclusive.StartNew(async () =>
{
    Step1();                 // exclusive
    await SaveAsync();       // releases the scheduler while the I/O is pending
    Step2();                 // resumes on the exclusive scheduler (Current captured), queued behind others
}).Unwrap();

Each synchronous segment is exclusive, but other work can run between segments, so it's not a true async lock. For mutual exclusion across awaits use SemaphoreSlim(1,1).

5. A minimal single-thread scheduler (STA example)

public sealed class SingleThreadScheduler : TaskScheduler, IDisposable
{
    private readonly BlockingCollection<Task> _queue = new();
    private readonly Thread _thread;

    public SingleThreadScheduler(ApartmentState apartment)
    {
        _thread = new Thread(() => { foreach (var t in _queue.GetConsumingEnumerable()) TryExecuteTask(t); })
        { IsBackground = true, Name = "sta-scheduler" };
        _thread.SetApartmentState(apartment);   // Windows only
        _thread.Start();
    }

    protected override void QueueTask(Task task) => _queue.Add(task);
    protected override bool TryExecuteTaskInline(Task task, bool prev) =>
        Thread.CurrentThread == _thread && TryExecuteTask(task);
    protected override IEnumerable<Task> GetScheduledTasks() => _queue.ToArray();
    public override int MaximumConcurrencyLevel => 1;
    public void Dispose() { _queue.CompleteAdding(); _thread.Join(); }
}

6. Analysers

7. Version notes

8. Try it yourself

1. Run the code example and note which inner task runs on the exclusive scheduler.
2. In a WPF app, use ContinueWith(..., FromCurrentSynchronizationContext()), call StartNew with a Thread.Sleep(5000) inside it, and watch the UI freeze.
3. Add TaskCreationOptions.HideScheduler to the outer task and observe Current becomes Default inside it.
4. Use the exclusive scheduler with an async lambda containing await Task.Delay(100); run two of them and log interleaving.
5. Enable CA2008 and see which calls it flags in your codebase.
6. Implement the single-thread scheduler and confirm all tasks run on the same ManagedThreadId.

var pair = new ConcurrentExclusiveSchedulerPair();
var factory = new TaskFactory(pair.ExclusiveScheduler);

await factory.StartNew(() =>
{
    Console.WriteLine($"Outer on exclusive: {TaskScheduler.Current == pair.ExclusiveScheduler}");

    // Pitfall: StartNew uses TaskScheduler.Current, so this is ALSO exclusive (serialised).
    Task inner = Task.Factory.StartNew(() =>
        Console.WriteLine($"Inner StartNew on exclusive: {TaskScheduler.Current == pair.ExclusiveScheduler}"));

    // Safe: explicit Default, or Task.Run.
    Task safe = Task.Factory.StartNew(
        () => Console.WriteLine($"Explicit default: {TaskScheduler.Current == TaskScheduler.Default}"),
        CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

    Task run = Task.Run(() => Console.WriteLine($"Task.Run default: {TaskScheduler.Current == TaskScheduler.Default}"));
    return Task.WhenAll(safe, run); // inner runs after this outer task ends (exclusive)
}).Unwrap();

pair.Complete();
await pair.Completion;