Elegant use of Tasks on the Unity game loop

I need to work with Tasks in my Unity component. In FixedUpdate, I need to call an async method, which returns right away, giving me a Task. Whenever the Task completes, I also need to handle the result in (a future) FixedUpdate (and then repeat the process).

So my code looks roughly like this:

void FixedUpdate() {
  if (_task == null) {
    _task = CallAsyncMethod();
  } else if (_task.isCompleted) {
    var result = _task.Result;
    ApplyResult(result);
    _task = null;
  }
}

This feels like an awkward use of Task due to the fact that I need to handle the result on the game loop, but I can't think of anything fundamentally wrong with it.

Questions:

• Is my implementation correct and not wasteful?
• Is there a more elegant way to satisfy the same constraints? (i.e. both start a Task and handle its result in FixedUpdate)

In my experience, trying to use async patterns with Unity's update loop is an endless exercise in frustration, as it tends to spawn many edge cases.

Your best bet is to avoid async at all costs and use Coroutines instead.

If you absolutely must use async functions, consider spawning your own separate thread at the beginning of the game to manage and invoke them. But then you have to figure out thread-safe ways to exchange data back to the main game thread.

You could at least skip the null check and rather directly start a new task after the first one finished. That would make it look less "ugly" and also remove the delay of one FixedUpdate interval

void Start()
{ 
    _task = CallAsyncMethod(); 
} 

void FixedUpdate() 
{ 
    if (!_task.isCompleted) return;

    var result = _task.Result;
    ApplyResult(result); 
    _task = CallAsyncMethod(); 
}

Or use a Coroutine like e.g.

private IEnumerator Start ()
{
    while(true)
    {
       var task = CallAsyncMethod();
       yield return new WaitUntil(() => task.isCompleted);  
       yield return new WaitForFixedUpdate();
       var result = _task.Result;
       ApplyResult(result);  
    }
}

But if you really want to do async stuff in Unity in its full potential you should check out UniTask and do e.g.

void Start()
{
    ApplyContinously().Forget();
}

private async UniTaskVoid ApplyContinously()
{
    while(true)
    {
        var result = await CallAsyncMethod();

        await UniTask.WaitForFixedUpdate();

        ApplyResult(result);
    }
}