{"id":96655,"date":"2017-07-20T07:00:00","date_gmt":"2017-07-20T21:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/oldnewthing\/?p=96655"},"modified":"2019-03-13T01:14:19","modified_gmt":"2019-03-13T08:14:19","slug":"20170720-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20170720-00\/?p=96655","title":{"rendered":"Crash course in async and await"},"content":{"rendered":"

I’m going to assume that you know how the async<\/code> and await<\/code> keywords work. If you need a refresher, you can read Eric Lippert’s extensive exposition of the subject<\/a>. Here’s the short version. People who know how async<\/code> and await<\/code> work can go take a nap.<\/b> <\/p>\n

When you write a function that is marked async<\/code>, then the function is broken up into a series of mini-functions at each await<\/code> call. The code executes synchronously up until the first await<\/code>, at which point the rest of the code is scheduled for resumption when the awaited thing produces a result. Optionally, a task is returned so that the caller can schedule its own continuation when the async function executes its return<\/code> statement. <\/p>\n

For example, let’s take this function: <\/p>\n

\nasync Task<int> GetTotalAsync()\n{\n  int total = GetStartValue();\n  int increment = await GetIncrementAsync();\n  return total + increment;\n}\n<\/pre>\n
This is shorthand for the following, with error checking has been elided for expository simplicity. <\/p>\n
\nTask<int> GetTotalAsync()\n{\n  int total = GetStartValue();\n  return GetIncrementAsync().ContinueWith((incrementTask) => {\n    int increment = incrementTask.Result;\n    return total + increment;\n  });\n}\n<\/pre>\n
(Actually, that’s not really what happens; here are the gory details<\/a>.) <\/p>\n
The point is that the function executes normally until it encounters the first await<\/code>, at which point it schedules itself as a continuation of the thing being awaited, and returns a new task that represents the continuation. When the thing being awaited completes, execution resumes with the continuation. That continuation might do some work, and then perform another await<\/code>, which once again schedules itself as a continuation of the thing being awaited. Eventually, the original function runs to completion, at which point the chain of tasks terminates with a result, namely the thing that the original function returned. <\/p>\n
Note that when dealing with async<\/code> functions, you have to distinguish with what the function returns<\/i> and what it produces<\/i> as a result<\/i> when it completes<\/i>. The return value<\/i> is the thing that is returned synchronously by the function, typically a task of some sort. When execution reaches the end of the task chain, the task is said to have completed<\/i>. The thing that comes out the end is called the result<\/i>. <\/p>\n
In other words, there are two ways to call an async<\/code> function. <\/p>\n
\nvar task = SomethingAsync();\nvar result = await SomethingAsync();\n<\/pre>\n
If you call it without await<\/code> then you get the raw task back. If you call it with await<\/code>, then when the task completes, you get the result. <\/p>\n
People who know how async<\/code> and await<\/code> work can start waking up now.<\/b> You still know the stuff coming up next, but at least you’ll be primed for the discussion to come after. <\/p>\n
There are three ways of writing an async<\/code> function: <\/p>\n
    \n
  • async Task<T> SomethingAsync() { ... return t; }<\/code> \n
  • async Task SomethingAsync() { ... }<\/code> \n
  • async void SomethingAsync() { ... }<\/code> <\/ul>\n
    In all the cases, the function is transformed into a chain of tasks. The difference is what the function returns. <\/p>\n
    In the first case, the function returns a task that eventually produces the t<\/code>. <\/p>\n
    In the second case, the function returns a task which has no product, but you can still await<\/code> on it to know when it has run to completion. <\/p>\n
    The third case is the nasty one. The third case is like the second case, except that you don’t even get the task back<\/i>. You have no way of knowing when the function’s task has completed. <\/p>\n
    The async void<\/code> case is a “fire and forget”: You start the task chain, but you don’t care about when it’s finished. When the function returns, all you know is that everything up to the first await<\/code> has executed. Everything after the first await<\/code> will run at some unspecified point in the future that you have no access to. <\/p>\n
    Now that I’ve set up the story, we’ll dig into the consequences next time. <\/p>\n","protected":false},"excerpt":{"rendered":"
    Hang on a second, I’ll get back to you.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-96655","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
    Hang on a second, I’ll get back to you.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/96655","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=96655"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/96655\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=96655"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=96655"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=96655"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}