Is Async await keyword equivalent to a ContinueWith lambda?
async-await, c#, continuations
Solution
The general idea is correct - the remainder of the method is made into a continuation of sorts.
The "fast path" blog post has details on how the `async`/`await` compiler transformation works.
Differences, off the top of my head:
The `await` keyword also makes use of a "scheduling context" concept. The scheduling context is `SynchronizationContext.Current` if it exists, falling back on `TaskScheduler.Current`. The continuation is then run on the scheduling context. So a closer approximation would be to pass `TaskScheduler.FromCurrentSynchronizationContext` into `ContinueWith`, falling back on `TaskScheduler.Current` if necessary.
The actual `async`/`await` implementation is based on pattern matching; it uses an "awaitable" pattern that allows other things besides tasks to be awaited. Some examples are the WinRT asynchronous APIs, some special methods such as `Yield`, Rx observables, and special socket awaitables that don't hit the GC as hard. Tasks are powerful, but they're not the only awaitables.
One more minor nitpicky difference comes to mind: if the awaitable is already completed, then the `async` method does not actually return at that point; it continues synchronously. So it's kind of like passing `TaskContinuationOptions.ExecuteSynchronously`, but without the stack-related problems.
Problem
Could someone please be kind enough to confirm if I have understood the Async await keyword correctly? (Using version 3 of the CTP) Thus far I have worked out that inserting the await keyword prior to a method call essentially does 2 things, A. It creates an immediate return and B. It creates a "continuation" that is invoked upon the completion of the async method invocation. In any case the continuation is the remainder of the code block for the method. So what I am wondering is, are these two bits of code technically equivalent, and if so, does this basically mean that the await keyword is identical to creating a ContinueWith Lambda (Ie: it's basically a compiler shortcut for one)? If not, what are the differences? ``` bool Success = await new POP3Connector( "mail.server.com", txtUsername.Text, txtPassword.Text).Connect(); // At this point the method will return and following code will // only be invoked when the operation is complete(?) MessageBox.Show(Success ? "Logged In" : "Wrong password"); ``` VS ``` (new POP3Connector( "mail.server.com", txtUsername.Text, txtPassword.Text ).Connect()) .ContinueWith((success) => MessageBox.Show(success.Result ? "Logged In" : "Wrong password")); ```