{"id":102362,"date":"2019-03-26T07:00:00","date_gmt":"2019-03-26T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=102362"},"modified":"2019-06-06T17:38:49","modified_gmt":"2019-06-07T00:38:49","slug":"20190326-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20190326-00\/?p=102362","title":{"rendered":"When do Core­Dispatcher.<\/CODE>Run­Async<\/CODE> and Thread­Pool.<\/CODE>Run­Async<\/CODE> actions complete?"},"content":{"rendered":"

The Core­Dispatcher::<\/code>Run­Async<\/code> and Thread­Pool::<\/code>Run­Async<\/code> methods take a delegate and schedule it to be invoked on the dispatcher thread or on a thread pool thread. These methods return an IAsync­Action<\/code>, but when does that action complete? <\/p>\n

When dealing with asynchronous methods, there are two ways of talking about the result. <\/p>\n

First, there’s the return value of the asynchronous method, which at the ABI level is an IAsync­Action<\/code> or IAsync­Operation<\/code>. Depending on the language projection, this is exposed to the programmer as a language-specific object. <\/p>\n\n\n\n\n\n\n
Projection<\/th>\nIAsync­Action<\/code><\/th>\nIAsync­Operation<T><\/code><\/th>\nNotes<\/th>\n<\/tr>\n
C++\/WinRT<\/td>\nIAsync­Action<\/code><\/td>\nIAsync­Operation<T><\/code><\/td>\n<\/td>\n<\/tr>\n
C++\/CX<\/td>\nIAsync­Action^<\/code>
task<void><\/code><\/td>\n		IAsync­Operation<T>^<\/code>
task<T><\/code><\/td>\n		Projected as IAsyncXxx<\/code>
usually wrapped into
task<\/code>\/Task<\/code>.<\/td>\n<\/tr>\n
C#<\/td>\nIAsync­Action<\/code>
Task<\/code><\/td>\n		IAsync­Operation<T><\/code>
Task<T><\/code><\/td>\n<\/tr>\n
JavaScript<\/td>\nPromise<\/code><\/td>\nPromise<\/code><\/td>\n<\/td>\n<\/tr>\n<\/table>\n

The second result is the thing that you receive when the asynchronous operation completes. <\/p>\n\n\n\n\n\n\n\n
Projection<\/th>\nIAsync­Action<\/code><\/th>\nIAsync­Operation<T><\/code><\/th>\n<\/tr>\n
C++\/WinRT<\/td>\nvoid<\/code><\/td>\nT<\/code><\/td>\n<\/tr>\n
C++\/CX<\/td>\nvoid<\/code><\/td>\nT<\/code><\/td>\n<\/tr>\n
C++\/CX + PPL<\/td>\nvoid<\/code><\/td>\nT<\/code><\/td>\n<\/tr>\n
C#<\/td>\nvoid<\/code><\/td>\nT<\/code><\/td>\n<\/tr>\n
JavaScript<\/td>\nundefined<\/code><\/td>\nT<\/code><\/td>\n<\/tr>\n<\/table>\n

And there’s also a third thing to worry about, which is when<\/i> you receive that completion result. <\/p>\n

Let’s answer the three questions for the Core­Dispatcher::<\/code>Run­Async<\/code> and Thread­Pool::<\/code>Run­Async<\/code> methods. <\/p>\n

First, they return<\/i> an IAsync­Action<\/code>. The methods schedule the delegate to be invoked later, and then return an IAsync­Action<\/code> representing the pending operation. <\/p>\n

Second, they complete<\/i> with void<\/code>. There is no additional information reported when the operation completes. <\/p>\n

Third (and most interesting) is that they complete when the delegate returns<\/i><\/a>. <\/p>\n

Not when the delegate completes<\/i>. <\/p>\n

This means that when you pass a delegate that itself represents an asynchronous operation, the IAsync­Action<\/code> returned by Run­Async<\/code> completes once your delegate returns its own async operation. The dispatcher or thread pool doesn’t even see that async operation; it’s eaten by your language projection. All that the dispatcher or thread pool knows is that it invoked the delegate, and the delegate returned void<\/code>, so we must be done. <\/p>\n

The C++\/WinRT, and JavaScript projections permit your delegate to return someting, even though the formal function signature returns void<\/code>. The projection just throws your return value away, and the caller gets nothing. The C# language lets you make a function formally return void<\/code>, even though it secretly continues running asynchronously. The syntax for this is async void<\/code>, and I’ve discussed the perils of async void<\/code><\/a> in the past. <\/p>\n

This means that if you await the result of a Run­Async<\/code>, the await will complete when your delegate either returns or performs its own await operation, whichever comes first. <\/p>\n

\n\/\/ C++\/WinRT\n\nco_await Dispatcher().RunAsync(CoreDispatcherPriority::Normal,\n    [lifetime = get_strong()]() -> fire_and_forget\n    {\n        co_await SomethingAsync();\n        co_await SomethingElseAsync();\n        Finished();\n    });\n\n\/\/ C++\/CX\n\ncreate_task(Dispatcher->RunAsync(CoreDispatcherPriority::Normal,\n    ref new DispatchedHandler([this]()\n    {\n        create_task(SomethingAsync()).then([this]() {\n            return create_task(SomethingElseAsync());\n        }).then([this]() {\n            Finished();\n        });\n    }))).then([this]()\n    {\n        BackOnMainThread();\n    });\n\n\n\/\/ C++\/CX + co_await\n\nco_await Dispatcher->RunAsync(CoreDispatcherPriority::Normal,\n    ref new DispatchedHandler([this]()\n    {\n        []() -> task<void>\n        {\n            co_await SomethingAsync();\n            co_await SomethingElseAsync();\n            Finished();\n        }();\n    }));\nBackOnMainThread();\n\n\/\/ C#\n\nawait Dispatcher.RunAsync(CoreDispatcherPriority::Normal, async () =>\n    {\n        await SomethingAsync();\n        await SomethingElseAsync();\n        Finished();\n    });\nBackOnMainThread();\n\n\/\/ JavaScript (pretend)¹\n\nawait dispatcher.runAsync(CoreDispatcherPriority.normal, async () =>\n    {\n        await somethingAsync();\n        await somethingElseAsync();\n        finished();\n    });\nbackOnMainThread();\n<\/pre>\n
When does the await<\/code>\/co_await<\/code> complete and the Back­On­Main­Thread<\/code> run? <\/p>\n
Answer: When Something­Async<\/code> returns its IAsync­Action<\/code>, that action gets wrapped inside a coroutine, and execution suspends, returning control to the dispatcher or thread pool. At this point, the delegate has returned, and the Run­Async<\/code> declares its action to have completed. The object representing the coroutine (the IAsyncAction<\/code>, task<\/code>, Task<\/code>, or Promise<\/code>) is simply discarded. <\/p>\n
In C++\/WinRT and JavaScript, the discarding is done by the projection. In C++\/CX, the discarding is explicit in the code: Observe that we create a task but do not return<\/code> it. In C#, the discarding is done by the language itself because an async<\/code> lambda can be implicitly converted to a non-async void<\/code> lambda (by treating it as if were async void<\/code>). <\/p>\n
Another way of looking at this analysis is that the lambda returns when it encounters its first await<\/code>\/co_await<\/code> or return<\/code>. This in turn causes the Run­Async<\/code> to complete its own IAsync­Action<\/code>. <\/p>\n
If we write things out explicitly, the sequence of operations might be more clear: <\/p>\n
\n\/\/ C#\nasync () =>\n{\n    await SomethingAsync();\n    await SomethingElseAsync();\n    Finished();\n}\n<\/pre>\n
This gets transformed by the compiler into <\/p>\n
\nclass Lambda\n{\n    async void Invoke()\n    {\n        await SomethingAsync();\n        await SomethingElseAsync();\n        Finished();\n    }\n}\n<\/pre>\n
which gets further transformed into <\/p>\n
\nclass Lambda\n{\n    void Invoke()\n    {\n        Task task1 = SomethingAsync();\n        task1.ContinueWith(_ => {\n            Task task2 = SomethingElseAsync();\n            task2.ContinueWith(_ => {\n                Finished();\n            });\n        });\n    }\n}\n<\/pre>\n
Once Something­Async<\/code> returns its Task<\/code>, the lambda attaches a continuation to it, so that it can resume execution when the task completes. At that point, the outer lambda has finished its work, and the Invoke<\/code> method returns. This returns control back to the delegate or thread pool, which declares that the Run­Async<\/code> has completed. And the completion of Run­Async<\/code> means that Back­On­Main­Thread<\/code> starts to run. <\/p>\n
This behavior is usually not what you want. You want to wait until the lambda has completed<\/i>, not just returned. We’ll look at one possible solution next time. <\/p>\n
¹ JavaScript is a single-threaded language, so you can’t actually do this, but I included it for completeness to demonstrate what would<\/i> happen if it were possible. <\/p>\n","protected":false},"excerpt":{"rendered":"
When the delegate returns, not when it completes.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-102362","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
When the delegate returns, not when it completes.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102362","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=102362"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/102362\/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=102362"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=102362"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=102362"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}