create_async在UI线程的行为及内部异步任务执行时机问询

Great question! Let's break down exactly how create_async behaves on the UI thread and walk through the execution timing of your code step by step.

When you call create_async from the UI thread (a single-threaded apartment/STA thread), the asynchronous operation it creates is bound to the current UI thread's context by default. This means any task continuations (like your .then callback) will automatically schedule back to the UI thread unless you explicitly specify otherwise—this matches what you've read about context-aware tasks sticking to their originating apartment thread.

Let's walk through what happens when you call GetImage() from the UI thread:

1. Immediate return of IAsyncOperation
   As soon as you call GetImage(), create_async will instantly hand you back an IAsyncOperation<BitmapImage^> object. The lambda you passed to create_async doesn't run right away—it gets queued to the UI thread's message loop, waiting for the current batch of synchronous UI work (like the event handler that called GetImage(), ongoing rendering, or other pending UI tasks) to finish.

2. Execution of the outer lambda & GetStreamAsync()
   Once the UI thread is free (its message loop picks up the queued task), the outer lambda runs. Inside it, create_task(GetStreamAsync()) kicks off the GetStreamAsync() operation.

   • If GetStreamAsync() is an I/O-bound operation (like fetching a file or network stream), its core work will likely run on a background thread (this depends on how GetStreamAsync is implemented). But regardless of where it runs, the continuation (your .then callback) will default back to the UI thread context.

3. The .then callback runs on the UI thread
   When GetStreamAsync() completes, the .then callback is queued to the UI thread's message loop again. It won't interrupt any ongoing UI work—only when the thread is free will it execute.
   Inside this callback, you create the BitmapImage and call SetSourceAsync(stream). A quick note here: your current code doesn't wait for SetSourceAsync to finish before returning the BitmapImage. That's okay for most UI binding scenarios (the BitmapImage will update automatically once loaded), but if you need to guarantee the image is fully loaded before returning, you should wrap SetSourceAsync in a task and await it:

   return create_task(image->SetSourceAsync(stream)).then([image] { return image; });
   

4. Returning the BitmapImage
   Once the .then callback finishes, the result is propagated back through the IAsyncOperation to whatever is awaiting GetImage().

• All UI-thread-bound tasks (the create_async lambda, the .then callback) are queued and executed in order—they never preempt currently running UI code.
• If you wanted part of the workflow to run on a background thread (e.g., processing the stream before creating the BitmapImage), you could override the continuation context with task_continuation_context::use_arbitrary() in your .then call. But since you're working with BitmapImage (a UI element), you must create it and call SetSourceAsync on the UI thread.

内容的提问来源于stack exchange，提问作者Craig