Most Appropriate Use Of Async/Await When Not Returning The Task Directly?

Question

I use async await a lot in my code, but it's occurred to me that I might not be doing it as appropriately as I should be.

I'm looking for confirmation of my understanding of the best way to handle async/await for methods which do multiple things and don't return the result of the task directly.

This is what I'd usually do when I just want to directly return the result of the task.

    //basic - 1 thing to do - directly return task
    public Task<string> ReturningATask(string key)
    {
        return _cache.GetStringAsync(key);
    }

However when I want to do something with the value of the task before returning, I've had the habit of just async'ing the method and awaiting the task within.

    //More than a single operation going on.
    //In this case I want to just return a bool indicating whether or not the key exists.
    public async Task<bool> ReturningABool(string key)
    {
        string foundValue = await _cache.GetStringAsync(key);

        if (string.IsNullOrEmpty(foundValue))
        {
            return false;
        }
        else
        {
            return true;
        }
    }

It occurs to me that ContinueWith is probably the more appropriate way to handle this.

Is the below example the generally the accepted way to handle this? I got into my head "never use task.Result as it's blocking", but with ContinueWith, the task is already completed, so there's no blocking right?

    //The more correct way?        
    public Task<bool> ReturningATaskBool(string key)
    {
        return _cache.GetStringAsync(key)
            .ContinueWith(x =>
            {
                if (string.IsNullOrEmpty(x.Result))
                {
                    return false;
                }
                else
                {
                    return true;
                }
            });
    }

Thanks.

Answer 1

ContinueWith is a dangerous, low-level API. Specifically, it:

• Does not understand asynchronous continuations.
• Uses the current TaskScheduler (not the default TaskScheduler ) as the default value for its TaskScheduler parameter.
• Does not have appropriate default behavior for continuation flags (eg, DenyChildAttach ).

await has none of these problems. You should use await instead of ContinueWith .

See my blog for an exhaustive (exhausting?) discussion .

Answer 2

Most of the time it doesn't make much of a difference. async/await has probably slightly more overhead than ContinueWith (though it really depends on the scenario), but I doubt that's something you should worry about. Just go for the one you find easier to read.

The only thing you should be careful about is that await will post the continuation to the current synchronization context, if any. This may be especially useful if you're in a winform/wpf application. On the other hand, ContinueWith executes the continuation on the current task scheduler (usually the threadpool).

I got into my head "never use task.Result as it's blocking", but with ContinueWith, the task is already completed, so there's no blocking right?

That's correct, the way you use ContinueWith is fine.