Dispatcher.BeginInvoke（）不异步运行

Question

Here's a simplified version of what I want to do:

onClick a button , a aNewMethod() would run asynchronously to keep UI responsive. That's it!

I've read some answers and here's what i could come up with :

    private async void button_Click(object sender, RoutedEventArgs e)
    {
        Task task = Task.Run(() => aNewMethod());
        await task;
    }

    private void aNewMethod()
    {
        if (progress.Value == 0)
        {
            //Heavy work
            for (int i = 1; i < 1000000000; i++) { }
            progress.Value = 100;
        }
    }

As you may have thought, this throws a System.InvalidOperationException at if(progress.Value== 0) saying :

The calling thread cannot access this object because a different thread owns it.

after some Googling, I've read that I need a Dispatcher.BeginInvoke() method to update/use UI controls, so I did this :

    private void aNewMethod()
    {
        Dispatcher.BeginInvoke((Action)delegate {
            if (progress.Value == 0)
            {
                //Heavy work
                for (int i = 1; i < 1000000000; i++) { }
                progress.Value = 100;
            }
        });
     }

This solved the System.InvalidOperationException but it's not running asynchronously as the UI still freezes at for loop

So the question is : How to run the aNewMethod(); asynchronously and still update and interact with UI controls ?

Answer 1

The Dispatcher runs in the UI thread. It handles your UI, and executes actions you pass to it via BeginInvoke etc. But it can only handle one thing at a time; when it's busy handling your action, it won't update the UI in the meantime, so the UI freezes in the meantime.

If you want to keep your UI responsive, you'd need to run the heavy load functions in a seperate, non-UI thread. Within those functions running on another thread, you can call the dispatcher whenever you need access to the UI - ideally, only very briefly for the purpose of updating UI elements.

So in other words, you'd want to be running your sleep function in a seperate thread, and then just make a call to the Dispatcher from your own thread when you need to set the progress value. Something like

private void button_Click(object sender, RoutedEventArgs e)
{
    Task task = Task.Run(() => aNewMethod());  // will call aNewMethod on the thread pool
}

private void aNewMethod()
{
    double progressValue = 0;
    Dispatcher.Invoke(() => progressValue = progress.Value);

    if (progressValue == 0)
    {
        Thread.Sleep(3000); // still executes on the threadpool (see above), so not blocking UI
        Dispatcher.Invoke(() => progress.Value = 100 );  // call the dispatcher to access UI
    }
}

Answer 2

With you current implementation, there is no need to use Thread.Start , as in that method you are just sleeping it for some time and accessing UI thread objects there which is not allowed .In your scenario a better way of doing is that you should not use Thread.Sleep instead of that you should be doing it with Task.Delay like:

private async void button_Click(object sender, RoutedEventArgs e)
{
        if (progress.Value == 0)
        {
             await Task.Delay(3000); 
             progress.Value = 100;
        } 


}

Now you don't need Dispatcher.Invoke , and credit goes to async and await keywords as statements after await will be executing in the same calling synchronization context from where we did async call which is UI thread in this case.

Answer 3

onClick a button, a aNewMethod() would run asynchronously to keep UI responsive.

Actually, it's running synchronously on a background thread . Task.Run is perfectly appropriate for this.

after some Googling, I've read that I need a Dispatcher.BeginInvoke() method to update/use UI controls

Unfortunately, this is one area where Google will certainly mislead you. Dispatcher is not the best solution here.

Instead, you should use IProgress<T> / Progress<T> , as such:

private async void button_Click(object sender, RoutedEventArgs e)
{
  var progress = new Progress<int>(value => { this.progress.Value = value; });
  await Task.Run(() => aNewMethod(progress));
}

private void aNewMethod(IProgress<int> progress)
{
  //Heavy work
  for (int i = 1; i < 1000000000; i++) { }
  progress.Report(100);
}