250116 ‐ Async - cywongg/2025 GitHub Wiki

Great question! Let’s break this down step by step to analyze what happens in your code and how await works in this situation. We'll also clarify whether the UI thread will be blocked and how you can ensure it remains unblocked.

When you use await in an async method:

• The current thread (UI thread in this case) is not blocked.
• Instead, the method starts the awaited operation (e.g., Task.WhenAll(...)), and control is immediately returned to the caller (e.g., to the WPF framework or the calling method).
• When the awaited task completes, the execution resumes after the await statement on the same thread that originally called it (in the case of WPF, this is the UI thread).

So in your code:

await Task.WhenAll(restrikingTask, corporateActionTask);

• This will start both restrikingTask and corporateActionTask concurrently in background threads (because you’re using Task.Run).
• The HandleAsiaSpecificLogicAsync method will pause execution at the await line and allow the UI thread to continue handling user interactions.
• Once both tasks complete, the method resumes its execution after the await line, and the rest of the method runs.

Let’s analyze your code step by step.

1. Initialization of IcomDataUpdateMonitor and otherDBs:

   • These are synchronous operations (no await or Task.Run).
   • They will run on the UI thread and block it temporarily until they complete. However, if these operations are fast, the blocking will be negligible.

2. Check for Asia-Specific Logic:

   • If asiaSettings.IsAsia is true, the method calls HandleAsiaSpecificLogicAsync.
   • The await keyword ensures that StartDatafeedsAsync pauses its execution at this point while the tasks in HandleAsiaSpecificLogicAsync are running in the background.
   • The UI thread is not blocked here because the long-running operations are offloaded to background threads using Task.Run.

3. Refresh the UI:

   • After the await HandleAsiaSpecificLogicAsync() completes, the RefreshUI() method is called.
   • This happens after the long-running tasks have finished, but the UI thread was free during their execution.

1. Start Long-Running Tasks:

   • restrikingTask and corporateActionTask are started using Task.Run, which offloads their execution to background threads.
   • These tasks do not run on the UI thread, so the UI thread remains free.

2. Await Both Tasks:

   • await Task.WhenAll(restrikingTask, corporateActionTask); makes the method pause execution at this line until both tasks complete.
   • However, the UI thread is not blocked. Instead, it returns to the WPF framework's message loop and remains free to handle user interactions (e.g., resizing the window, clicking on buttons, etc.).

No, StartDatafeedsAsync will not block the UI thread as long as:

1. The long-running operations (e.g., restrikingValidationService.Init and corporateActionService.Init) are properly offloaded to background threads using Task.Run.
2. You are using await to asynchronously wait for the tasks to complete.

Here’s why:

• The synchronous parts of StartDatafeedsAsync (like initializing IcomDataUpdateMonitor and otherDBs) will block the UI thread temporarily, but they are likely quick operations.
• The await keyword ensures that the UI thread is not blocked while waiting for the tasks in HandleAsiaSpecificLogicAsync to complete.

While the tasks in HandleAsiaSpecificLogicAsync are running:

1. The UI thread is free to handle user interactions (move the window, click buttons, etc.).
2. The UI may show "empty" or "loading" content in certain parts (e.g., grids or tabs) until the data is fully loaded and RefreshUI() is called.
3. If you’ve implemented a loading indicator (like a spinner or "Loading..." message), it will remain visible until the tasks complete.

Here are the key points to ensure the UI thread remains unblocked:

Make sure all long-running operations (restrikingValidationService.Init and corporateActionService.Init) are offloaded to background threads using Task.Run.

var restrikingTask = Task.Run(() => restrikingValidationService.Init(myInstruments.Values));
var corporateActionTask = Task.Run(() =>
{
    ICollection<string> prIndexes = GetPrIndexes();
    ICollection<string> prStocks = GetPrStocks();
    DateTime latestNextFixingDate = GetLatestNextFixingDate();
    corporateActionService.Init(prIndexes, prStocks, from: DateTime.Today, to: latestNextFixingDate);
});

Using await allows the UI thread to return to the WPF message loop while the tasks are running in the background. This keeps the UI responsive.

await Task.WhenAll(restrikingTask, corporateActionTask);

The RefreshUI method should only update the UI and avoid any heavy processing. If it involves significant computation, offload that part to a background thread and only update the UI on the main thread.

private void RefreshUI()
{
    Application.Current.Dispatcher.Invoke(() =>
    {
        // UI updates go here
    });
}

If you want to visually indicate that data is being loaded, you can use a loading indicator (e.g., a spinner or "Loading..." text). This keeps the user informed while the background tasks are running.

Here’s how your code behaves:

1. StartDatafeedsAsync Begins:

   • Initializes IcomDataUpdateMonitor and otherDBs synchronously (minor blocking if these are fast).
   • Calls await HandleAsiaSpecificLogicAsync().

2. HandleAsiaSpecificLogicAsync Starts:

   • Runs the two long-running tasks (restrikingTask and corporateActionTask) in the background using Task.Run.
   • The UI thread is free during this time.

3. Awaiting Task.WhenAll:

   • The method pauses at await Task.WhenAll(...).
   • The UI thread remains responsive while waiting for the tasks to complete.

4. Tasks Complete:

   • After both tasks finish, StartDatafeedsAsync resumes and calls RefreshUI() to update the UI.

5. UI Updates:

   • The UI is updated with the loaded data, and any loading indicator is hidden.

• Does StartDatafeedsAsync block the UI thread?

  • No, as long as the long-running tasks are properly offloaded using Task.Run and await is used.

• When does the UI thread remain free?

  • During the execution of the background tasks (restrikingTask and corporateActionTask).
  • While await Task.WhenAll is waiting for the tasks to complete.

• Will the UI show empty data while tasks are running?

  • Yes, unless you implement a loading indicator.

Let me know if you need further clarification or adjustments!