Can I create a C# async method without using a different thread (Task)?

user_10800072 0
Viewed 125

I have searched a lot and it seems C# async await has to be used together with Task. The situation is that I have a method that is very time consuming which is OK, but I hope it won't block the main method.

So I describe the main method as "async", and inside it, I call and "await" the time consuming method, but C# need the time consuming method to be included in a Task which means it will be executed in a seperate thread. But that method has something that cannot run outside main thread.

And my question is how can I run the time consuming method asynchronously without putting it in a different thread?

Thank you very much.

PS: I'm doing this in Unity3D, is it possible to leverage Coroutine to reach the goal?

//main method
private async void MainMethod()
{
  //...
  bool result = await TimeConsumingMethod();
  //...
}

//time consuming method
private async Task<bool> TimeConsumingMethod()
{
  bool result;
  await Task.Run(()=> 
    {
      //...
      //SOME CODE THAT CANNOT run in thread other than main
      //...
    });
    return result;
}
unity3d c#
2 Answers

To run anything aysnchronously (not blocking the main thread) in unity you have to use a different Thread/Task.

But as you also want to run code on the main thread in that separate thread you'll have to communicate between the two.

Although you can't run anything on the main thread from inside a different thread. You can make a queue that the main thread consistently handles. When the off thread then wants to do something on the main thread it adds it to the queue and the mainThreadHandler will then handle it in the next frame update. So the off thread can then tell the main thread that it wants to do something on the main thread and wait for the main thread to be done with that code and then continue with the processing after.

This is an implementation of a main thread handler:

public class MainThreadHandler:MonoBehaviour
{
    private static readonly Queue<Action> _executionQueue = new Queue<Action>();
    
    public void Update()
    {
        lock (_executionQueue)
        {
            while (_executionQueue.Count > 0)
            {
                _executionQueue.Dequeue().Invoke();
            }
        }
    }

    public static void Enqueue(Action action)
    {
        lock (_executionQueue)
        {
            _executionQueue.Enqueue(action);
        }
    }
}

Calling your code including calling things in the main thread and then waiting for it will then look something like this:

private Task currentTask;
private bool taskResult;

public void StartOffThreadMethod()
{
    currentTask = Task.Run(() =>
    {
        DoCalculationsOffThread();

        bool isMainThreadDone = false;
        MainThreadHandler.Enqueue(() =>
        {
            //Main thread code

            //Either set a bool that the off thread checks to see if the action has been completed
            //or start a new task that handles the rest of the off threaded code 
            //This example uses a isDone bool
            isMainThreadDone = true;
        });

        while (!isMainThreadDone)
        {
            Thread.Sleep(100);
        }

        DoOtherCalculationsOffThread();
        taskResult = true;
    });
}

private void Update()
{
    if (currentTask != null && currentTask.IsCompleted)
    {
        //do stuff with the result
    }
}

I'd also like to add that going back and forth between the main thread and an calculating thread can be rather tricky business. If it can be prevented i would try to prevent it.

user_192005540

To put your async operation in the main thread you should use coroutines and that's why it's there. C# task can't run sync with unity itself.

In example, let's assume you write that async operation as coroutine and if you change timescale, it will also effect the coroutine but task will not or when you stop play mode in editor, task will still be runnning and many other issues.

From the docs However, it’s important to remember that coroutines aren’t threads. Synchronous operations that run within a coroutine still execute on the main thread.

user_100990930
Related