How can I run several methods (all with onComplete callback) asynchronously one after the onComplete of another method is triggered?

Question

I'm using Unity and C# for a small project.

I have a list of person class instances, and each of them has the following method,

public void DoWork(Action onComplete) { }  //onComplete is triggered when everything is done in the method.

I want to run the DoWork methods of all persons asynchronously one after the onComplete of another person DoWork is triggered. That is to say that the first person DoWork asynchronously, and after its onComplete is triggered, the second person DoWork asynchronously, go on untill all persons complete their works.

The method DoWork is currently not an async function, it would be great if I don't need to change this.

I'm wondering how shall I design the code? Is it possible to achieve the purpose without leveraging the .net Task? If not, how can I modify the DoWork method? BTW, Unity doesn't allow me to run the method in a thread (like a Task thread) that is not the main thread.

I tried the following solution. DoWork has an onComplete callback because inside it, there is a tool.Start() function which has an onComplete callback and needs to be executed, DoWork can only be done when tool.Start() onComplete is triggered. So I remoeved onComplete callback for DoWork, and wrote the following code.

public async Task DoWork()
{
    bool allowExit = false;
    tool.Start(() =>        //Start function has an Action onComplete callback, and DoWork can only be done when Start onComplete is triggered
    {
        allowExit = true;
    });
    while (!allowExit) { await Task.Yield(); }
}

public async void AllPersonsDoWork()    //try to run all persons' DoWork methods asynchronously one by one
{
    foreach (var person in personList)
    {
        await person.DoWork();
    }
}

Unity3D doesn't give a threading error, but it freazes.

Any tip is appreicated, thank you very much.

Have you considered a queue and to put the work in a queue and take them and in the oncomplete just take the next in the queue till all are gone? — BugFinder, Jan 08 '23 at 23:08
@BugFinder is it possible to do everything asynchronously with the queue you mentioned? Any tip that how can I create the queue? I updated my question to include my solution that is not working though. Thanks for your reply. — solidcomer, Jan 08 '23 at 23:26
Well. I thought you wanted each person in turn. However. Rather than all this have you looked at the unity job system which does allow parallel jobs? — BugFinder, Jan 08 '23 at 23:33
I'd recommend [UniTask](https://github.com/Cysharp/UniTask) it makes async code in Unity and in particular the forth and back between asynchronous and main thread context a lot easier .. in general: what does that `tool.Start` do? Maybe you are getting exception in there which is swallowed by the async task — derHugo, Jan 09 '23 at 06:26
You could use a [`TaskCompletionSource`](https://stackoverflow.com/questions/15316613/when-should-taskcompletionsourcet-be-used) btw instead of that `while` loop — derHugo, Jan 09 '23 at 07:40
@BugFinder that sounds like an advanced tech, I think it worth learning for a more flexible solution for similar issues. Thanks. — solidcomer, Jan 09 '23 at 18:42
@derHugo let me try TaskCompletionSource, that looks promising, thanks. — solidcomer, Jan 09 '23 at 18:43
@BugFinder job system itself isn't hard but requires case specific optimizations and is mainly good for calculations ... As long as we don't know what `DoWork` really is doing it is hard to recommend any tools .. I wouldn't throw the JobSysten at something except I know that the burst compiler can really improve performance — derHugo, Jan 10 '23 at 05:28

score 1 · Answer 1 · answered Jan 09 '23 at 16:14

As others have mentioned, you can use Queue and a method to check for Queue size and chain DoWork's to each other. but beware that if an exception occurs in one the DoWork methods all the chain of works will stop.

You can use this sample code:

public Queue<Person> TasksToDo;
    
    public async Task CheckQueue()
    {
        if( TasksToDo.Count > 0){
            var person = TasksToDo.Dequeue();
            await person.DoWork(CheckQueue);
        }
    }
    
    public class Person
    {
        public async Task DoWork(Func<Task> onComplete)
        {
            //..... do work
            if (onComplete != null)
            {
                await onComplete();             
            }
        }
    }

The point about the exception is either desired (otherwise why chain them at all) or should be covered by try catch to allow the rest to continue anyway — derHugo, Jan 10 '23 at 05:26

Stephen Cleary · Answer 2 · 2023-01-10T23:14:26.330

First, I recommend wrapping the DoWork with a TAP wrapper. Callbacks are somewhat similar to events, so you can mostly follow this guidance. An extension method is not too difficult to write:

public static class PersonExtensions
{
  public Task DoWorkAsync(this Person person)
  {
    var tcs = new TaskCompletionSource();
    try
    {
      person.DoWork(() => tcs.TrySetComplete());
    }
    catch (Exception ex)
    {
      tcs.TrySetException(ex);
    }
    return tcs.Task;
  }
}

The catch block above only handles synchronous errors. Asynchronous errors aren't handled, since the Action onComplete handler doesn't have a way to represent asynchronous errors. Usually, completion callbacks like this are either Action<Exception?> onComplete or Action onSuccess, Action<Exception> onFailure.

Once you have a DoWorkAsync, calling it for each person is straightforward:

async Task AllPersonsDoWork()
{
  foreach (var person in personList)
    await person.DoWorkAsync();
}

I was trying to understand the TaskCompletionSource suggestion, from @derHugo, which sounds promising, now I understand how it works. Thanks a lot. — solidcomer, Jan 10 '23 at 15:57

How can I run several methods (all with onComplete callback) asynchronously one after the onComplete of another method is triggered?

2 Answers2