The continuation of the task (built by async / await) is performed in the main thread in the WPF application, but on the child in the console application

Question

Suppose I have a simple C# console application:

 class Program { static async void func() { Thread.CurrentThread.Name = "main"; await Task.Run(() => { Thread.CurrentThread.Name = "child"; Thread.Sleep(5000); }); Console.WriteLine("continuation is running on {0} thread", Thread.CurrentThread.Name); } static void Main(string[] args) { func(); Thread.Sleep(10000); } } 

When the skip is 5000 ms, we see the message "Continuation works on the child thread." When another 5000 ms passes, the main thread exits and the application closes. This looks pretty logical: the asynchronous task and its continuation are executed on one child thread.

But suppose I have a simple WPF application:

 public partial class MainWindow : Window { public MainWindow() { InitializeComponent(); } async private void mainWnd_MouseLeftButtonDown(object sender, MouseButtonEventArgs e) { Thread.CurrentThread.Name = "main"; await Task.Run(() => { Thread.CurrentThread.Name = "child"; Thread.Sleep(5000); }); this.Title = string.Format("continuation is running on {0} thread", Thread.CurrentThread.Name); } private void mainWnd_MouseRightButtonDown(object sender, MouseButtonEventArgs e) { Thread.Sleep(10000); } } 

Now, when we press the left mouse button and skip 5000 ms, we see that the heading “continue working on the main thread”. In addition, if we press the left button and then the right button, the application will first start the mainWnd_MouseLeftButtonDown handler, then the mainWnd_MouseRightButtonDown handler (in the main thread), the main thread will sleep for 10,000 ms, and then continue the asynchronous task from mainWnd_MouseLeftButtonDown to continue to be executed flow.

Why is the async-await mechanism different for these two situations?

I know that the WPF method can be explicitly launched in the user interface thread through Dispatcher.Invoke , but the async-await mechanism is not WPF specific, so its behavior should be equal in any kind of application, shouldn it?

Any help would be appreciated.

Answer 1

async-await corresponds to the current scope of the SynchronizationContext . This means that the context (if it exists) is fixed at the start of the asynchronous operation and, at the end of the continuation, is planned in the captured context.

UI applications ( WPF / Winforms ) use SynchronizationContext , which allows only the main UI thread to interact with UI elements, so it works seamlessly with async-await .

ASP.Net also has its own SynchronizationContext , called AspNetSynchronizationContext (surprisingly). So this is not necessarily about UI or Single Apartments .

---

If you want to disable this useful SynchronizationContext capture, you just need to use ConfigureAwait :

 await Task.Run(() => { Thread.CurrentThread.Name = "child"; Thread.Sleep(5000); }).ConfigureAwait(false); 

Learn more about SynchronizationContexts: All about SynchronizationContext