Program.CurrentThreadSynchronizationContext.cs

using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;

namespace CSharpScriptRunner
{
    static partial class Program
    {
        sealed class SynchronizationContextScope : IDisposable
        {
            readonly SynchronizationContext _syncCtx;
            bool _isDisposed = true;
            public SynchronizationContextScope() => _syncCtx = SynchronizationContext.Current;

            public void Install(SynchronizationContext synchronizationContext)
            {
                Dispose();
                SynchronizationContext.SetSynchronizationContext(synchronizationContext);
                _isDisposed = false;
            }

            public System.Runtime.CompilerServices.YieldAwaitable InstallAndYield(SynchronizationContext synchronizationContext)
            {
                Install(synchronizationContext);
                return Task.Yield();
            }

            public void Dispose()
            {
                if (_isDisposed)
                    return;
                _isDisposed = true;
                var current = SynchronizationContext.Current;
                if (current == _syncCtx)
                    return;
                if (current is IDisposable disposable)
                    disposable.Dispose();
                SynchronizationContext.SetSynchronizationContext(_syncCtx);
            }
        }

        sealed class CurrentThreadSynchronizationContext : System.Threading.SynchronizationContext, IDisposable
        {
            readonly BlockingCollection<(SendOrPostCallback Callback, object State)> _queue = new();
            int _isRunning;
            public CurrentThreadSynchronizationContext() { }
            public override void Send(SendOrPostCallback d, object state) => throw new InvalidOperationException();
            public override void Post(SendOrPostCallback d, object state)
            {
                _queue.Add((d, state));
                if (Interlocked.Exchange(ref _isRunning, 1) != 0)
                    return;
                foreach (var item in _queue.GetConsumingEnumerable())
                    item.Callback(item.State);
            }

            public void Dispose() => _queue.CompleteAdding();
        }
    }
}