Using ContinueWith() on an awaited task and calling Task.Result inside

Question

I came across the following code that uses the ContinueWith() to wait for the result.

public async Task<User> GetUser()
{
    return await _serviceRepo.GetUserAsync()
       .ContinueWith(task => 
       {
           return task.Result;
       });
}

Does the ContinueWith() block the calling thread until task returns from the GetUserAsync() call?

Since the task.Result is inside the ContinueWith() which is scheduled, is anything being blocked while waiting for the antecedent task?

I've seen this type of code in couple of other places, is this considered a best practice for the async/await pattern? I would expect the GetUserAsync() call return the result than using a ContinueWith() to wait for it.

You are not using `ContinueWith` on awaited `Task`. You are awaiting continuation `Task`, created by `ContinueWith`. BTW, why not use `public Task GetUser() => _serviceRepo.GetUserAsync();` — user4003407, Dec 11 '17 at 04:22
There is no reason to do it like this. You can remove async, await, and ContinueWith completely. — Evk, Dec 11 '17 at 06:03

score 7 · Answer 1 · answered Dec 14 '17 at 21:36

Does the ContinueWith() block the calling thread until task returns from the GetUserAsync() call?

No, the thread wouldn't be blocked, as this is an async operation. Just be aware that the given code awaits not the task, but the continuation, which may mislead you during debugging.

Since the task.Result is inside the ContinueWith() which is scheduled, is anything being blocked while waiting for the antecedent task?

No, the task is already finished, and the current thread wouldn't be blocked. However, the exception will be raised in case the task finished unsuccessfully.

is this considered a best practice for the asyn/await pattern?

No, this code can be rewritten in form:

public async Task<User> GetUser()
{
    return await _serviceRepo.GetUserAsync();
}

However, if there is some logic in continuation, like this:

public async Task<User> GetUser()
{
    return await _serviceRepo.GetUserAsync()
       .ContinueWith(task => 
       {
           // do something with the result, for example, log the success

           return task.Result;
       });

you can do this:

public async Task<User> GetUser()
{
    var user = await _serviceRepo.GetUserAsync();

    // do something with the result, for example, log the success

    return user;
}

I would also rename `GetUser` to `GetUserAsync` here to follow convention, and also you can remove the async modifier from the method signature and even `return _serviceRepo.GetUserAsync();` directly, as the method `GetUserAsync` will be awaited by it's caller, so you can avoid the creation of the async state machine overhead by returning the task directly, iit does not need to be awaited in this method, because we do not use the `user` variable directly after. — David B, Feb 03 '21 at 11:00
@DavidB This is true in case of simple method structure similar to above. In general case such logic can be more complicated, and simple task return wouldn't be enough — VMAtm, Feb 03 '21 at 11:35

Using ContinueWith() on an awaited task and calling Task.Result inside

1 Answers1