Task caused UI Freezing - WPF

Question

The structure of my code is shown below:

internal async Task ButtonClickMethod()
{
    await this.InitializeMethod();
}
internal async Task InitializeMethod()
{
    await this.Call();
}

private async Task Call()
{
    await this.CallTasks();
}

private async Task CallTasks()
{
    List<Task> tasks = new List<Task>();
    tasks.Add(/*time-consuming task A*/);
    tasks.Add(/*time-consuming task B*/);
    tasks.Add(/*time-consuming task C*/);
    tasks.Add(/*time-consuming task D*/);

    await Task.WhenAll(tasks);
}

Task defined as follows:

/*time-consuming task*/
internal async Task TimeConsuming()
{
    // code...
    await Task.Run(() =>
    {
        // code... A/B/C/D
    });
    // code...
}

Is there any problem with this code that will cause the UI to freeze?

Is the problem caused by Task.WhenAll?

Answer 1

Use this instead :

    private async void ClickButton(object sender, RoutedEventArgs e)
    {
       await ThatFirstMethod(any parameters);
    }
    
    private async Task ThatFirstMethod(any parameters)
    {
       await Task.Run(() => {
          ThatFirstTimeConsumingMethod(any param);
       });
       await Task.Run(() => {
          ThatSecondTimeConsumingMethod(any param);
       });
    }
   private bool ThatFirstTimeConsumingMethod(any param)
   {
       //code
       return true;
   }
   .....

If you have to access UI Elements you will not be able to do so, beacause your "heavy" methods are being processed by another Thread. Here's a solution :

private bool ThatFirstTimeConsumingMethod(any param)
{
   string s = "";
   Application.Current.Dispatcher.Invoke(() => {
      s = myTextBox.Text;
   });

   // do what you want with the s variable

   Application.Current.Dispatcher.Invoke(() => {
      myTextBox.Text = s;
   });
   return true;
}

So basically, you're asking your main Thread to execute an action (where your UI is getting processed) with Application.Current.Dispatcher.Invoke. And when you're in the await Task.Run you're asking another thread to process the heavy action.