Main thread dispatcher for Unity.

MainThreadDispatcher.cs

using System;
using System.Threading;

// TODO: Make sure Singleton implementation is also thread-safe.

/// <summary>
/// Provides means of executing code on the main Unity thread while in other threads.
/// </summary>
public class MainThreadDispatcher
{
    private readonly SynchronizationContext _syncContext = SynchronizationContext.Current;

    /// <summary>
    /// Dispatches an action to the Unity main thread, and waits for either an answer or action completion.
    /// </summary>
    /// <remarks>
    /// This code, when run in a background thread:
    /// <code>
    /// Debug.Log("Before");
    /// MainThreadDispatcher.Instance.DispatchAndWait(() =&gt; Debug.Log("Inside"));
    /// Debug.Log("After");
    /// </code>
    /// Produces the following console output:
    /// <code>
    /// Before
    /// Inside
    /// After
    /// </code>
    /// Notice 'After' appearing after 'Inside'.
    /// </remarks>
    /// <seealso cref="DispatchFireAndForget"/>
    public void DispatchAndWait(Action action)
    {
        _syncContext.Send(_ => action?.Invoke(), null);
    }

    /// <summary>
    /// Dispatches an action to the Unity main thread but doesn't wait for an answer or action completion.
    /// </summary>
    /// <remarks>
    /// This code, when run in a background thread:
    /// <code>
    /// Debug.Log("Before");
    /// MainThreadDispatcher.Instance.DispatchFireAndForget(() =&gt; Debug.Log("Inside"));
    /// Debug.Log("After");
    /// </code>
    /// Produces the following console output:
    /// <code>
    /// Before
    /// After
    /// Inside
    /// </code>
    /// Notice 'After' appearing before 'Inside'.
    /// </remarks>
    /// <seealso cref="DispatchAndWait"/>
    public void DispatchFireAndForget(Action action)
    {
        _syncContext.Post(_ => action?.Invoke(), null);
    }

    //
    // Alternative implementation below with a ConcurrentQueue:
    //

    // private readonly ConcurrentQueue<Action> _queue = new ConcurrentQueue<Action>();
    //
    // public void Dispatch(Action action)
    // {
    //     _queue.Enqueue(action);
    // }
    //
    // private void Update()
    // {
    //     if (_queue.IsEmpty)
    //     {
    //         return;
    //     }
    //
    //     while (_queue.TryDequeue(out var action))
    //     {
    //         action?.Invoke();
    //     }
    // }
}