.NET Fiddle

CSharp · Console

/Program.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Collections.Concurrent;
			
#nullable enable

public class Program
{
	public static async Task Main()
	{
		using var dispatcher = SimpleDispatcher.StartNew();
		
		var task1 = dispatcher.SendAsync(async () =>
		{
			Console.WriteLine($"Task 1: Thread {Thread.CurrentThread.ManagedThreadId}");
			await Task.Delay(100);
			Console.WriteLine($"Task 1: Thread {Thread.CurrentThread.ManagedThreadId}");
		});
		
		var task2 = dispatcher.SendAsync(async () =>
		{
			Console.WriteLine($"Task 2: Thread {Thread.CurrentThread.ManagedThreadId}");
			await Task.Delay(100);
			Console.WriteLine($"Task 2: Thread {Thread.CurrentThread.ManagedThreadId}");
		});
		
		await Task.WhenAll(task1, task2);
		
		Console.WriteLine("All tasks complete");
	}
}

public class SimpleDispatcher : IDisposable
{
    private readonly BlockingCollection<QueueItem> queue = new();
	private readonly CancellationTokenSource disposeCts = new();
	private readonly Thread thread;
	
	public SimpleDispatcher()
	{
		thread = new Thread(Run);
	}
	
	public static SimpleDispatcher StartNew()
	{
		var dispatcher = new SimpleDispatcher();
		dispatcher.Start();
		return dispatcher;
	}
	
	public void Start()
	{
		if (thread.IsAlive)
			throw new InvalidOperationException("Already running");
	
		thread.Start();
	}
	
	public void Post(SendOrPostCallback callback, object? state)
	{
		var item = new QueueItem
		{
			Delegate = () =>
			{
				callback(state);
				return Task.CompletedTask;
			},
			Tcs = new(),
		};
	
		queue.Add(item);
		
		// Re-throw any resulting exceptions on the ThreadPool
		async void RethrowExceptions()
		{
			await item.Tcs.Task;
		}
		RethrowExceptions();
	}
	
	public void Send(SendOrPostCallback callback, object? state)
	{
		var item = new QueueItem
		{
			Delegate = () =>
			{
				callback(state);
				return Task.CompletedTask;
			},
			Tcs = new(),
		};
	
		queue.Add(item);
		
		item.Tcs.Task.Unwrap().GetAwaiter().GetResult();
	}
	
	public Task SendAsync(Func<Task> func)
	{
		var item = new QueueItem
		{
			Delegate = func,
			Tcs = new(),
		};
		
		queue.Add(item);
		
		return item.Tcs.Task.Unwrap();
	}
	
	private void Run()
	{
		SynchronizationContext.SetSynchronizationContext(new SimpleDispatcherSynchronizationContext(this));
	
		try
		{
			while (true)
			{
				var item = queue.Take(this.disposeCts.Token);

				try
				{
					var task = item.Delegate();
					item.Tcs.SetResult(task);
				}
				catch (Exception e)
				{
					item.Tcs.SetException(e);
				}
			}
		}
		catch (OperationCanceledException) { }
	}
	
	public void Dispose()
	{
		disposeCts.Cancel();
	}
	
	private struct QueueItem
	{
		public Func<Task> Delegate;
		// When complete, the message has been processed, and the TCS contains the Task returned by Delegate
		public TaskCompletionSource<Task> Tcs;
	}
}

public class SimpleDispatcherSynchronizationContext : SynchronizationContext
{
	private readonly SimpleDispatcher dispatcher;
	
	public SimpleDispatcherSynchronizationContext(SimpleDispatcher dispatcher) => this.dispatcher = dispatcher;

	public override void Send(SendOrPostCallback d, object? state)
	{
		dispatcher.Send(d, state);
	}
	
	public override void Post(SendOrPostCallback d, object? state) 
	{
		dispatcher.Post(d, state);
	}
	
	public override SynchronizationContext CreateCopy() => new SimpleDispatcherSynchronizationContext(dispatcher);
}
;