Handle result returned by async call within async method

Question

Imagine this is a method performing a DB query and returning a result, which in case of null is replaced with a default value (Null object pattern).

public ResultObj Get()
{
    var result = dbContext.GetSomeResult();

    return result ?? ResultObj.NullValue;
}

Imagine this DB query is a long-running process, so I would use async/await to execute this process in a separate thread. Suppose that the dbContext.GetSomeResultAsync() method is available.

How can be this method converted in an asynchronous one so that I can write something like this?

var resultTask = GetAsync();
var otherResultTask = GetSomethingElseAsync();

Task.WaitAll(resultTask, otherResultTask);

var myResult = resultTask.Result;
var myOtherResult = otherResultTask.Result;

I tried this solution.

public async Task<ResultObj> GetAsync()
{
    var result = await dbContext.GetSomeResultAsync();

    return result ?? ResultObj.NullValue;
}

First, I'm wondering why this code compiles: why can I return ResultObj when Task<ResultObj> is expected?

Second, this code predictably results in a deadlock, as clearly explained by the great number of resources about async deadlocks anti-patterns. The deadlock can be prevented by using .ConfigureAwait(false) method after the async call. Is this the right way to go? Are there any hidden drawbacks in this case? Is it a general rule?

I also tried this.

public async Task<ResultObj> GetAsync()
{
    return await Task.Run(() => {
        var result = dbContext.GetSomeResult();

        return result ?? ResultObj.NullValue;
    });
}

This results in a deadlock, too. This time I cannot even figure out why.

Edit: possible solution

Finally, after having read this, I found a solution to my problem.

My generic query wrapper method is like this.

public async Task<ResultObj> GetAsync()
{
    var result = await dbContext.GetSomeResultAsync();

    return result ?? ResultObj.NullValue;
}

On calling method, I use this pattern.

public async Task<CollectedResults> CollectAsync()
{
    var resultTask = GetAsync();
    var otherResultTask = GetSomethingElseAsync();

    //here both queries are being executed.
    //...in the while, optionally, here some other synchronous actions

    //then, await results
    var result = await resultTask;
    var otherResult = await otherResultTask;

    //here process collected results and return

    return new CollectedResults(...);
}

It is worth mentioning that the above code, wrapped in a domain class, is called by a Controller action. In order for this to work I had to make async the methods all the way up, until Controller action, which now appears as follows.

public async Task<CollectedResults> Get()
{
    return await resultsCollector.CollectAsync();
}

This way, deadlock doesn't happen anymore and execution time greatly improves with respect to the synchronous version.

I don't know if this is the canonical way of executing parallel queries. But it works and I don't see particular pitfalls in the code.

It compiles because of async/await. It's a feature of the keyword. If you'd return a `Task ` you'd get an error. Could you tell me why this would result in a deadlock? — Kenneth, Mar 22 '18 at 22:51
Also, async/await does not mean a different thread. It rather means that while you're waiting on the result from the Db, rather than blocking the thread, you can have the thread do something else and come back to it when the result is available. — Kenneth, Mar 22 '18 at 22:53
Thanks. Actually, I can return `Task` with no errors. Deadlock happens beacuse of something like this: https://blog.stephencleary.com/2012/07/dont-block-on-async-code.html — Marcello, Mar 23 '18 at 18:03

score 1 · Answer 1 · answered Mar 22 '18 at 22:54

First of all, regarding :

so I would use async/await to execute this process in a separate thread.

There is no new thread created when we use async and await

Secondly:

why can I return ResultObj when Task is expected?

the Task<TResult> as return type of method tells that it returns a Task of type TResult but we need to return object of type that TResult back from it so the method can be awaited and when using Task<TResult> as reutrn type we should be using async and await to do the work.

Lastly:

this code predictably results in a deadlock

You are using async keyword with method signatures and also await the next async method call being done from within the method. So apparently it looks like the code in first example you have posted shouldn't be deadlocked, if the method GetSomeResultAsync you are consuming is really a async method and is properly implemented.

I suggest to study more about the async await before getting in to it, following is a good article to start with:

https://blog.stephencleary.com/2012/02/async-and-await.html

Thanks for the interesting link. My async method is certainly well implemented, since it belongs to a common library. So far, no solution to my problem. I have no problems if I directly return `Task` without checking for null within the async method (then checking each time outside after the call). — Marcello, Mar 23 '18 at 18:17

Handle result returned by async call within async method

Edit: possible solution

1 Answers1