How to update UI from another thread running in another class

Question

I am currently writing my first program on C  and I am extremely new to the language  used to only work with C so far   I have done a lot of research  but all answers were too general and I simply couldn t get it t work   So here my  very common  problem  I have a WPF application which takes inputs from a few textboxes filled by the user and then uses that to do a lot of calculations with them  They should take around 2-3 minutes  so I would like to update a progress bar and a textblock telling me what the current status is  Also I need to store the UI inputs from the user and give them to the thread  so I have a third class  which I use to create an object and would like to pass this object to the background thread  Obviously I would run the calculations in another thread  so the UI doesn t freeze  but I don t know how to update the UI  since all the calculation methods are part of another class  After a lot of reasearch I think the best method to go with would be using dispatchers and TPL and not a backgroundworker  but honestly I am not sure how they work and after around 20 hours of trial and error with other answers  I decided to ask a question myself   Here a very simple structure of my program   public partial class MainWindow   Window       public MainWindow                 Initialize Component               private void startCalc object sender  RoutedEventArgs e                inputValues input   new inputValues             calcClass calculations   new calcClass             try                        input pota   Convert ToDouble aVar Text                input potb   Convert ToDouble bVar Text                input potc   Convert ToDouble cVar Text                input potd   Convert ToDouble dVar Text                input potf   Convert ToDouble fVar Text                input potA   Convert ToDouble AVar Text                input potB   Convert ToDouble BVar Text                input initStart   Convert ToDouble initStart Text                input initEnd   Convert ToDouble initEnd Text                input inita   Convert ToDouble inita Text                input initb   Convert ToDouble initb Text                input initc   Convert ToDouble initb Text                       catch                         MessageBox Show  Some input values are not of the expected Type     Wrong Input   MessageBoxButton OK  MessageBoxImage Error                       Thread calcthread   new Thread new ParameterizedThreadStart calculations testMethod            calcthread Start input          public class inputValues       public double pota  potb  potc  potd  potf  potA  potB      public double initStart  initEnd  inita  initb  initc     public class calcClass       public void testmethod inputValues input                Thread CurrentThread Priority   ThreadPriority Lowest          int i            the input object will be used somehow  but that doesn t matter for my problem         for  i   0  i  lt  1000  i                          Thread Sleep 10                       I would be very grateful if someone had a simple explanation how to update the UI from inside the testmethod  Since I am new to C  and object oriented programming  too complicated answers I will very likely not understand  I ll do my best though   Also if someone has a better idea in general  maybe using backgroundworker or anything else  I am open to see it

User · Answer

I am going to throw you a curve ball here. If I have said it once I have said it a hundred times. Marshaling operations like Invoke or BeginInvoke are not always the best methods for updating the UI with worker thread progress.

In this case it usually works better to have the worker thread publish its progress information to a shared data structure that the UI thread then polls at regular intervals. This has several advantages.

It breaks the tight coupling between the UI and worker thread that Invoke imposes.
The UI thread gets to dictate when the UI controls get updated...the way it should be anyway when you really think about it.
There is no risk of overrunning the UI message queue as would be the case if BeginInvoke were used from the worker thread.
The worker thread does not have to wait for a response from the UI thread as would be the case with Invoke.
You get more throughput on both the UI and worker threads.
Invoke and BeginInvoke are expensive operations.

So in your calcClass create a data structure that will hold the progress information.

public class calcClass
{
  private double percentComplete = 0;

  public double PercentComplete
  {
    get 
    { 
      // Do a thread-safe read here.
      return Interlocked.CompareExchange(ref percentComplete, 0, 0);
    }
  }

  public testMethod(object input)
  {
    int count = 1000;
    for (int i = 0; i < count; i++)
    {
      Thread.Sleep(10);
      double newvalue = ((double)i + 1) / (double)count;
      Interlocked.Exchange(ref percentComplete, newvalue);
    }
  }
}

Then in your MainWindow class use a DispatcherTimer to periodically poll the progress information. Configure the DispatcherTimer to raise the Tick event on whatever interval is most appropriate for your situation.

public partial class MainWindow : Window
{
  public void YourDispatcherTimer_Tick(object sender, EventArgs args)
  {
    YourProgressBar.Value = calculation.PercentComplete;
  }
}

User · Answer

You re right that you should use the Dispatcher to update controls on the UI thread  and also right that long-running processes should not run on the UI thread  Even if you run the long-running process asynchronously on the UI thread  it can still cause performance issues   It should be noted that Dispatcher CurrentDispatcher will return the dispatcher for the current thread  not necessarily the UI thread  I think you can use Application Current Dispatcher to get a reference to the UI thread s dispatcher if that s available to you  but if not you ll have to pass the UI dispatcher in to your background thread   Typically I use the Task Parallel Library for threading operations instead of a BackgroundWorker  I just find it easier to use   For example   Task Factory StartNew      gt       SomeObject RunLongProcess someDataObject      where  void RunLongProcess SomeViewModel someDataObject        for  int i   0  i  lt   1000  i                  Thread Sleep 10               Update every 10 executions         if  i   10    0                           Send message to UI thread             Application Current Dispatcher BeginInvoke                  DispatcherPriority Normal                   Action       gt  someDataObject ProgressValue    i   1000

User · Answer

If this is a long calculation then I would go background worker   It has progress support   It also has support for cancel    http   msdn microsoft com en-us library cc221403 v VS 95  aspx   Here I have a TextBox bound to contents       private void backgroundWorker RunWorkerCompleted object sender  RunWorkerCompletedEventArgs e                Debug Write  backgroundWorker RunWorkerCompleted            if  e Cancelled                        contents    Cancelled get contents                NotifyPropertyChanged  Contents                      else if  e Error    null                        contents    An Error Occured in get contents               NotifyPropertyChanged  Contents                      else                       contents    string e Result              if  contentTabSelectd  NotifyPropertyChanged  Contents

User · Answer

Felt the need to add this better answer  as nothing except BackgroundWorker seemed to help me  and the answer dealing with that thus far was woefully incomplete   This is how you would update a XAML page called MainWindow that has an Image tag like this    lt Image Name  imgNtwkInd  Source  Images network on jpg  Width  50    gt    with a BackgroundWorker process to show if you are connected to the network or not   using System ComponentModel  using System Windows  using System Windows Controls   public partial class MainWindow   Window       private BackgroundWorker bw   new BackgroundWorker         public MainWindow                 InitializeComponent                Set up background worker to allow progress reporting and cancellation         bw WorkerReportsProgress   true          bw WorkerSupportsCancellation   true              This is your main work process that records progress         bw DoWork    new DoWorkEventHandler SomeClass DoWork               This will update your page based on that progress         bw ProgressChanged    new ProgressChangedEventHandler bw ProgressChanged               This starts your background worker and  DoWork            bw RunWorkerAsync                When this page closes  this will run and cancel your background worker         this Closing    new CancelEventHandler Page Unload              private void bw ProgressChanged object sender  ProgressChangedEventArgs e                BitmapImage bImg   new BitmapImage            bool connected   false          string response   e ProgressPercentage ToString       will either be 1 or 0 for true false -- this is the result recorded in DoWork            if  response     1               connected   true              Do something with the result we got         if   connected                        bImg BeginInit                bImg UriSource   new Uri  Images network off jpg   UriKind Relative               bImg EndInit                imgNtwkInd Source   bImg                    else                       bImg BeginInit                bImg UriSource   new Uri  Images network on jpg   UriKind Relative               bImg EndInit                imgNtwkInd Source   bImg                       private void Page Unload object sender  CancelEventArgs e                bw CancelAsync        stops the background worker when unloading the page           public class SomeClass       public static bool connected   false       public void DoWork object sender  DoWorkEventArgs e                BackgroundWorker bw   sender as BackgroundWorker           int i   0          do                        connected   CheckConn        do some task and get the result              if  bw CancellationPending    true                                e Cancel   true                  break                            else                               Thread Sleep 1000                      Record your result here                 if  connected                      bw ReportProgress 1                   else                     bw ReportProgress 0                                   while  i    0              private static bool CheckConn                 bool conn   false          Ping png   new Ping            string host    SomeComputerNameHere            try                       PingReply pngReply   png Send host               if  pngReply Status    IPStatus Success                  conn   true                    catch  PingException ex                           write exception to log                   return conn            For more information   https   msdn microsoft com en-us library cc221403 v VS 95  aspx

User · Answer

First you need to use Dispatcher Invoke to change the UI from another thread and to do that from another class  you can use events  Then you can register to that event s  in the main class and Dispatch the changes to the UI and in the calculation class you throw the event when you want to notify the UI   class MainWindow   Window       private void startCalc                   your code         CalcClass calc   new CalcClass            calc ProgressUpdate     s  e    gt                Dispatcher Invoke  Action delegate        update UI                           Thread calcthread   new Thread new ParameterizedThreadStart calc testMethod            calcthread Start input            class CalcClass       public event EventHandler ProgressUpdate       public void testMethod object input                  part 1         if ProgressUpdate    null              ProgressUpdate this  new YourEventArgs status              part 2           UPDATE  As it seems this is still an often visited question and answer I want to update this answer with how I would do it now  with  NET 4 5  - this is a little longer as I will show some different possibilities     class MainWindow   Window       Task calcTask   null       void buttonStartCalc Clicked object sender  EventArgs e    StartCalc          1     async void buttonDoCalc Clicked object sender  EventArgs e      2               await CalcAsync        2            void StartCalc                 var calc   PrepareCalc            calcTask   Task Run      gt  calc TestMethod input        3           Task CalcAsync                 var calc   PrepareCalc            return Task Run      gt  calc TestMethod input        4           CalcClass PrepareCalc                   your code         var calc   new CalcClass            calc ProgressUpdate     s  e    gt  Dispatcher Invoke  Action delegate                                    update UI                         return calc           class CalcClass       public event EventHandler lt EventArgs lt YourStatus gt  gt  ProgressUpdate      5      public TestMethod InputValues input                  part 1         ProgressUpdate Raise this  status       6 - status is of type YourStatus           part 2          static class EventExtensions       public static void Raise lt T gt  this EventHandler lt EventArgs lt T gt  gt  theEvent                                  object sender  T args                if  theEvent    null              theEvent sender  new EventArgs lt T gt  args               1  How to start the  synchronous  calculations and run them in the background     2  How to start it  asynchronous  and  await it   Here the calculation is executed and completed before the method returns  but because of the async await the UI is not blocked  BTW  such event handlers are the only valid usages of async void as the event handler must return void - use async Task in all other cases      3  Instead of a new Thread we now use a Task  To later be able to check its  successfull  completion we save it in the global calcTask member  In the background this also starts a new thread and runs the action there  but it is much easier to handle and has some other benefits      4  Here we also start the action  but this time we return the task  so the  async event handler  can  await it   We could also create async Task CalcAsync   and then await Task Run      gt  calc TestMethod input   ConfigureAwait false    FYI  the ConfigureAwait false  is to avoid deadlocks  you should read up on this if you use async await as it would be to much to explain here  which would result in the same workflow  but as the Task Run is the only  awaitable operation  and is the last one we can simply return the task and save one context switch  which saves some execution time      5  Here I now use a  strongly typed generic event  so we can pass and receive our  status object  easily     6  Here I use the extension defined below  which  aside from ease of use  solve the possible race condition in the old example  There it could have happened that the event got null after the if-check  but before the call if the event handler was removed in another thread at just that moment  This can t happen here  as the extensions gets a  copy  of the event delegate and in the same situation the handler is still registered inside the Raise method

User · Answer

Thank God  Microsoft got that figured out in WPF     Every Control  like a progress bar  button  form  etc  has a Dispatcher on it  You can give the Dispatcher an Action that needs to be performed  and it will automatically call it on the correct thread  an Action is like a function delegate    You can find an example here   Of course  you ll have to have the control accessible from other classes  e g  by making it public and handing a reference to the Window to your other class  or maybe by passing a reference only to the progress bar

User · Answer

Everything that interacts with the UI must be called in the UI thread  unless it is a frozen object   To do that  you can use the dispatcher   var disp      Get the UI dispatcher  each WPF object has a dispatcher which you can query   disp BeginInvoke DispatcherPriority Normal           Action       gt    Do your UI Stuff here        I use BeginInvoke here  usually a backgroundworker doesn t need to wait that the UI updates  If you want to wait  you can use Invoke  But you should be careful not to call BeginInvoke to fast to often  this can get really nasty   By the way  The BackgroundWorker class helps with this kind of taks  It allows Reporting changes  like a percentage and dispatches this automatically from the Background thread into the ui thread  For the most thread  lt   update ui tasks the BackgroundWorker is a great tool

User · Answer

You are going to have to come back to your main thread  also called UI thread  in order to update the UI   Any other thread trying to update your UI will just cause exceptions to be thrown all over the place   So because you are in WPF  you can use the Dispatcher and more specifically a beginInvoke on this dispatcher  This will allow you to execute what needs done  typically Update the UI  in the UI thread    You migh also want to  register  the UI in your business  by maintaining a reference to a control form  so you can use its dispatcher

[c#] How to update UI from another thread running in another class

Examples related to c#

Examples related to wpf

Examples related to multithreading