How to initialize and call a static API always from a dedicated thread?

I have an API that needs to be called from the thread that initialized it. I want to make a wrapper that would create a thread for running all calls to the API and then allow me to await those calls from the UI. What would be an elegant way to do this in C#, without resorting to 3rd party libraries?

I am imagining the result looking something like this:

static class SingleThreadedApi
{
	public static void Init();

	// Has to be called from the same thread as init.
	public static double LongRunningCall();
}

class ApiWrapper
{
	// ???
}

class MyWindow
{
	ApiWrapper api = new();

	async void OnLoad()
	{
		await api.InitAsync();
	}

	async void OnButtonClick()
	{
		var result = await api.LongRunningCallAsync();
		answer.Text = "result: {result}";
	}
}

This question is similar to https://stackoverflow.com/questions/25691679/best-way-in-net-to-manage-queue-of-tasks-on-a-separate-single-thread, except there tasks only had to run serially, not necessarily on the same thread.

https://stackoverflow.com/questions/39271492/how-do-i-create-a-custom-synchronizationcontext-so-that-all-continuations-can-be might be one solution, but I hope there is something better than: "not the easiest thing in the world. I have an open-source [...] implementation."

So far, the best solution I found was to use a BlockingCollection<Action> with TaskCompletionSource. Simplified, it looks like this:

static class SingleThreadedAPi
{
	public static void Init();

	// Has to be called from the same thread as init.
	public static double LongRunningCall();
}

class ApiWrapper
{
	BlockingCollection<Action> actionQueue = new();

	public ApiWrapper()
	{
		new Thread(Run).Start();
	}

	public Task InitAsync()
	{
		var completion = new TaskCompletionSource();
		actionQueue.Add(() =>
		{
			try
			{
				SingleThreadedAPi.Init();
				completion.SetResult();
			}
			catch (Exception e)
			{
				completion.SetException(e);
			}
		});
		return completion.Task;
	}

	public Task<double> LongRunningCallAsync()
	{
		var completion = new TaskCompletionSource<double>();
		actionQueue.Add(() =>
		{
			try
			{
				
				completion.SetResult(SingleThreadedAPi.LongRunningCall());
			}
			catch (Exception e)
			{
				completion.SetException(e);
			}
		});
		return completion.Task;
	}

	public void Finish()
	{
		actionQueue.CompleteAdding();
	}

	void Run()
	{
		foreach (var action in actionQueue.GetConsumingEnumerable())
			action();
	}
}

class MyWindow
{
	ApiWrapper api;

	async void OnLoad()
	{
		await api.InitAsync();
	}

	async void OnButtonClick()
	{
		var result = await api.LongRunningCallAsync();
		answer.Text = "result: {result}";
	}
}

Pretty much any solution to this problem will be based on a BlockingCollection<T> one way or another, and the question becomes how to make the interaction with the BlockingCollection<T> more convenient. My suggestion is to wrap it in a custom TaskScheduler, that uses a single dedicated thread, and executes all the tasks on this thread. You can find material about how to write custom TaskSchedulers on this old article (the source code of the article can be found here), or you can just use the SingleThreadTaskScheduler implementation that I've posted here. It can be used like this:

class MyWindow
{
    private SingleThreadTaskScheduler _apiTaskScheduler;
    private TaskFactory _apiTaskFactory;

    async void OnLoad()
    {
        _apiTaskScheduler = new();
        _apiTaskFactory = new(_apiTaskScheduler);
        await _apiTaskFactory.StartNew(() => SingleThreadedApi.Init());
    }

    async void OnButtonClick()
    {
        double result = await _apiTaskFactory
            .StartNew(() => SingleThreadedApi.LongRunningCall());
        answer.Text = "result: {result}";
    }

    void OnClosed()
    {
        _apiTaskScheduler.Dispose();
    }
}

The Dispose is a blocking call. It will block the UI thread until all tasks that have been scheduled for execution are completed, and the dedicated thread is terminated. This is not ideal, but allowing the window to close before all operations are completed is probably even worse.

3: https://devblogs.microsoft.com/pfxteam/parallelextensionsextras-tour-7-additional-taskschedulers/ "ParallelExtensionsExtras Tour – #7 – Additional TaskSchedulers"
4: https://github.com/donatasm/ParallelExtensionsExtras/tree/master/src/TaskSchedulers "ParallelExtensionsExtras"
5: https://stackoverflow.com/questions/58379898/c-sharp-moving-database-to-a-separate-thread-without-busy-wait/58397942#58397942 "Moving Database to a separate thread, without busy wait"