Difference Await and ContinueWith

Question

I've read some threads regards the difference between await and ContinueWith. But no one has answer me completely.

I've got a DataAccess Layer that insert records in a database using Dapper. The InsertAsync method is:

public Task<int> InsertAsync(TEntity entity)
{
return Connection.InsertAsync(entity, Transaction).ContinueWith(r => Convert.ToInt32(r.Result));
}

I don't use async and await because in my head who will use this method will waiting for the result. Is correct?

Maybe it's a pre C# 5 code. It is essentially the same as `var result = await Connection.InsertAsync(...); return Convert.ToInt32(result);` Everything is after an await line is a continuation. So unless you want to target also .NET 4.0 you had better use async-await, which is much cleaner. — György Kőszeg, May 21 '21 at 08:18
Thanks, the code is in .NET 5. I switch to async-await as soon as possible — lele.lic, May 21 '21 at 12:37

Flater · Accepted Answer · 2021-05-21T09:03:20.190

I don't use async and await because in my head who will use this method will waiting for the result. Is correct?

That is not correct. While the await keyword does indeed wait for Connection.InsertAsync to complete before it calls Convert.ToInt32, the moment it starts waiting for Connection.InsertAsync it releases control back to its caller.

In other words, the caller will not be stuck waiting for Connection.InsertAsync to finish. The caller will be told "this will take a while, feel free to do something else", so it can continue.

Now, if the caller themselves was explicitly told to await the InsertAsync(TEntity) method on the same line that you call the method, then it will wait and it won't do anything else (except release control back to its caller), but that's because it was explicitly instructed to wait at that point.

To explain in code:

// I will wait for this result
var myInt = await Connection.InsertAsync(myEntity);

// I will not do this until I receive myInt
var sum = 1 + 1;
var anotherSum = 2 + 2;
var andAnotherSum = 3 + 3;

Without the await, the caller will just move on to the next command and do its work, all the way up to the point where it is finally told that it must await the task returned from InsertAsync(TEntity).

To explain in code:

// I will ask for this result but not wait for it
var myIntTask = Connection.InsertAsync(myEntity);

// I will keep myself busy doing this work
var sum = 1 + 1;
var anotherSum = 2 + 2;
var andAnotherSum = 3 + 3;

// My work is done. I hope the task is already done too.
// If not, I will have to wait for it because I can't put it off any longer.
var myInt = await myIntTask;

I've read some threads regards the difference between await and ContinueWith.

Functionally speaking, there is no difference between the two. However, the ContinueWith syntax has recently fallen out of popular favor, and the await syntax is much more favored because it reduces nesting and improves readability.

In terms of waiting, the behavior is exactly the same.

Personally, I suspect that ContinueWith is a leftover artifact from initially trying to design async methods the same way that promises in JS work, but this is just a suspicion.

Thank you. Your example is very clear. My only doubt was to use async / await in a layer that not is the GUI but you explained to me that is the right thing. — lele.lic, May 21 '21 at 12:36
`ContinueWith` is also a very low-level method that has [much more dangerous default behavior](https://blog.stephencleary.com/2013/10/continuewith-is-dangerous-too.html). Specifically, it doesn't understand `async` delegates and it has confusing default scheduling behaviour. `await` is the safer alternative that also makes the code more maintainable. — Stephen Cleary, May 21 '21 at 13:22

score 2 · Answer 2 · answered May 21 '21 at 08:42

That should be fine. However, there is a recommendation to always pass a taskscheduler to Continue with, to avoid any ambiguity of what context the continuation will run in, even if it does not matter in this particular case.

I would prefer the version

public async Task<int> InsertAsync(TEntity entity)
{
    var r = await Connection.InsertAsync(entity, Transaction);
    return Convert.ToInt32(r);
}

I consider this easier to read, and it will always execute the continuation on the same context as the caller. Behind the scenes it will produce very similar code to your example.

score 2 · Answer 3 · answered May 21 '21 at 08:54

You should definitely prefer async/await over the ContinueWith method.

public async Task<int> InsertAsync(TEntity entity)
{
    var result = await Connection.InsertAsync(entity, Transaction);
    return Convert.ToInt32(result);
}

The primitive ContinueWith method has many hidden gotchas. Exceptions thrown synchronously, exceptions wrapped in AggregateExceptions, TaskScheduler.Current ambiguity, SynchronizationContext not captured, nested Task<Task>s not properly unwrapped, will all come and bite you at one point or another, if you get in the habit of following the ContinueWith route.

Difference Await and ContinueWith

3 Answers3