C# - Unity 3d await task to complete in main thread

Question

I am using Unity 3D and I want to run task in main thread and await it to complete.

Here is my code:

public override Task<Vibranium.Protobuffers.ACSpawnData> WorldObjectSpawned(Vibranium.Protobuffers.WorldObjectData request, ServerCallContext context)
{
    ACSpawnData acSpawnData = new ACSpawnData();
    
    IEnumerator SpawnGo(ACSpawnData acSpawnData)
    {
        int spawnId = WorldObjectManager.Instance.GetWorldObjects.Count + 1;
        GameObject spawnedGO = GameObject.CreatePrimitive(PrimitiveType.Cube);
        spawnedGO.name = spawnId.ToString();
        spawnedGO.transform.SetParent(WorldObjectManager.Instance.transform);
        
        if (request.WorldObjectType == WorldObjectType.Player)
        {
            spawnedGO.GetComponent<Renderer>().material.color = Color.red;
        }
    
        WorldObjectManager.Instance.GetWorldObjects.Add(spawnedGO);

        acSpawnData.SpawnId = (uint)spawnId;
        acSpawnData.WorldObjectType = request.WorldObjectType;            


        yield return null;
    }   
    

    MainThreadDispatcher.Instance().Enqueue(SpawnGo(acSpawnData));
        
    return Task.FromResult(acSpawnData);
}

To execute IEnumerator in main thread I use this:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using System;
using System.Threading.Tasks;

/// Author: Pim de Witte (pimdewitte.com) and contributors, https://github.com/PimDeWitte/UnityMainThreadDispatcher
/// <summary>
/// A thread-safe class which holds a queue with actions to execute on the next Update() method. It can be used to make calls to the main thread for
/// things such as UI Manipulation in Unity. It was developed for use in combination with the Firebase Unity plugin, which uses separate threads for event handling
/// </summary>
public class MainThreadDispatcher : MonoBehaviour {

    private static readonly Queue<Action> _executionQueue = new Queue<Action>();

    public void Update() {
        lock(_executionQueue) {
            while (_executionQueue.Count > 0) {
                _executionQueue.Dequeue().Invoke();
            }
        }
    }

    /// <summary>
    /// Locks the queue and adds the IEnumerator to the queue
    /// </summary>
    /// <param name="action">IEnumerator function that will be executed from the main thread.</param>
    public void Enqueue(IEnumerator action) {
        lock (_executionQueue) {
            _executionQueue.Enqueue (() => {
                StartCoroutine (action);
            });
        }
    }

        /// <summary>
        /// Locks the queue and adds the Action to the queue
    /// </summary>
    /// <param name="action">function that will be executed from the main thread.</param>
    public void Enqueue(Action action)
    {
        Enqueue(ActionWrapper(action));
    }
    
    /// <summary>
    /// Locks the queue and adds the Action to the queue, returning a Task which is completed when the action completes
    /// </summary>
    /// <param name="action">function that will be executed from the main thread.</param>
    /// <returns>A Task that can be awaited until the action completes</returns>
    public Task EnqueueAsync(Action action)
    {
        var tcs = new TaskCompletionSource<bool>();

        void WrappedAction() {
            try 
            {
                action();
                tcs.TrySetResult(true);
            } catch (Exception ex) 
            {
                tcs.TrySetException(ex);
            }
        }

        Enqueue(ActionWrapper(WrappedAction));
        return tcs.Task;
    }

    
    IEnumerator ActionWrapper(Action a)
    {
        a();
        yield return null;
    }


    private static MainThreadDispatcher _instance = null;

    public static bool Exists() {
        return _instance != null;
    }

    public static MainThreadDispatcher Instance() {
        if (!Exists ()) {
            throw new Exception ("UnityMainThreadDispatcher could not find the UnityMainThreadDispatcher object. Please ensure you have added the MainThreadExecutor Prefab to your scene.");
        }
        return _instance;
    }


    void Awake() {
        if (_instance == null) {
            _instance = this;
            DontDestroyOnLoad(this.gameObject);
        }
    }

    void OnDestroy() {
            _instance = null;
    }


}

Everything works fine. The gameobject is created however Task.FromResult does not await SpawnGo to populate acSpawnData so acSpawnData is always returned empty.

How can I block the execution of Task WorldObjectSpawned until IEnumerator SpawnGo does it's job and populate acSpawnData so I can return it?

Answer 1

Instead of doing this directly with your own threading, you should utilize C#'s built-in async/await.

It allows you to spin off tasks, which manage the threads for you, and then you can decide when you need to wait for a task to complete before proceeding.

As a side benefit, it will also significantly streamline and reduce your code.