Chaining async calls together - call never returns

Question

I have a hierarchy of async calls I'm making. Looks basically like this:

async MyObject MainWorker()
{
    return await Task.Run(SomeSynchronousFunction);
}

async MyObject InbetweenFunction1()
{
    //do some things
    return await MainWorker();
}

async MyObject InbetweenFunction2()
{
    //do some things 
    return await MainWorker();
}

void ReturnObject TopFunction()
{
    Task<MyObject> return1 = InbetweenFunction1();
    Task<MyObject> return2 = InbetweenFunction2();

    while (!return1.IsComplete || !return2.IsComplete)
         Thread.Sleep(100);

    //access return1.Return and return2.Return values and return from this function
}

So I have a few levels of async calls. The top level method makes two async calls, waits for them to complete (via polling) and then accesses their return values and does something with the values. The problem is, none of the async calls ever finish. The function SomeSynchronousFunction which is called asynchronously with Task.Run should take a few seconds tops, but I wait 30+ seconds and no results.

This is my first attempt at using the new async/await keywords. Am I doing something obviously wrong?

What is `MyObject`? that code should not even compile, it should be `async Task InbetweenFunction1()` (unless MyObject is some class derived from `Task`). Please edit your question to make this a [SSCCE](http://www.sscce.org/) otherwise it will be hard to show you the correct way to do it if we can't understand what you are trying to do in the first place. — Scott Chamberlain, Mar 21 '14 at 02:38
Unless you absolutely need your main thread to block in a polling loop, you might want to call `await` on a `Task.WhenAll` with an array of your tasks. — joshtkling, Mar 21 '14 at 02:45
Check http://stackoverflow.com/questions/14485115/synchronously-waiting-for-an-async-operation-and-why-does-wait-freeze-the-pro?rq=1 ... Side note: it would be much easier to await results in sequence... — Alexei Levenkov, Mar 21 '14 at 02:55
You haven't specified the execution environment of this, my bet is it's either WinForms or WPF. Stephen Cleary explains the nature of the deadlock you're seeing, in great details: http://blog.stephencleary.com/2012/07/dont-block-on-async-code.html — noseratio, Mar 21 '14 at 03:28
@ScottChamberlain Even if `MyObject` did derive from `Task`, that code still wouldn't compile. — svick, Mar 21 '14 at 04:32

score 4 · Answer 1 · answered Mar 21 '14 at 10:29

Am I doing something obviously wrong?

Yes, you're doing busy waiting (looping until a condition becomes true), which you shouldn't do unless there is no other option. And there is a better option here: use Wait(), or Task.WaitAll().

But doing that most likely wouldn't actually make your code work. The real problem is probably the classic await deadlock: you're in a synchronization context (commonly either the UI thread or the ASP.NET request context) and your awaits try to resume on that context, but you're also blocking that context waiting on the Tasks to finish.

The right way to solve this would be to use await in TopLevelFunction() too. This would require you to make that function async too, which then means its caller now has to be async also, etc. This is called “async all the way”.

All the async methods should be async Task methods, with the exception of the top level event handlers, which has to be async void. (But you shouldn't use async void methods anywhere else, because they can't be awaited.)

This means your function would become:

async Task<ReturnObject> TopFunction()
{
    Task<MyObject> return1 = InbetweenFunction1();
    Task<MyObject> return2 = InbetweenFunction2();

    await Task.WhenAll(return1, return2);

    //access await return1 and await return2 values and return from this function
}

score 1 · Answer 2 · answered Mar 21 '14 at 03:48

Here is some workable code:

    private async Task<string> DoMainWork()
    {
        await Task.Delay(3000);
        return "MainWorker";
    }

    private async Task<string> InbetweenFunction1()
    {
        // do something
        await Task.Delay(1000);
        return await DoMainWork() + "1";
    }

    private async Task<string> InbetweenFunction2()
    {
        // do something
        await Task.Delay(2000);
        return await DoMainWork() + "2";
    }

    public string TopFunction()
    {
        string return1 = null;
        string return2 = null;

        var taskList = new List<Task>();
        taskList.Add(Task.Run(async () => return1 = await InbetweenFunction1()));
        taskList.Add(Task.Run(async () => return2 = await InbetweenFunction2()));

        Task.WaitAll(taskList.ToArray());

        return return1 + return2;
    }

score 0 · Answer 3 · answered Mar 21 '14 at 06:32

What you want is an extra function to combine the previous tasks

public async Task<string> Combine(Task<string> a, Task<string b){
    var aa = await a;
    var bb = await b;
    return aa + bb; 
}

and

public string TopFunction()
{
    var task = Combine(InBetweenFunction2(), InVetweenFunction2());

    // Blocking call
    // Really you shouldn't be doing this unless you really really
    // have to.
    task.Wait();

    return task.Result;
}

Note one of the places you really really have to use blocking calls is in the entry point main function of the application which can't be declared async and thus can't use await

Chaining async calls together - call never returns

3 Answers3