0

Like many applications, I want to update my status text when the application is doing long computation. I've read articles about Dispatcher and BackgroundWorker. I know I definitely need to make sure the the updates happen in the UI thread. My first try was:

MyView.UpdateStatus( "Please wait" );
LongComputation();
MyView.UpdateStatus( "Ready" );

This does not work because (I think) the LongComputation prevents the status being updated.

So I tried to do this:

BackgroundWorker worker = new BackgroundWorker();
MyView.UpdateStatus( "Please wait");
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
    LongComputation();
}
worker.RunWorkerAsync();
MyView.UpdateStatus( "Ready" );

I was hopping that the extra thread will give the UpdateStatus a chance to update status text. It does not work either. One of the reason is that the result of the LongComputation is displayed in a Windows Form. As soon as I put the LongComputation inside the BackgroundWorker, the result doesn't show up.

So I tried a third time by using the flowing code:

BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object s, DoWorkEventArgs args)
{
    Dispatcher.Invoke(((Action)(() => Status.Text = args.Argument as string)));
};

worker.RunWorkerAsync(newStatus);

I was hoping that putting the update in a another thread would work. But it didn't.

What can I do to make sure that the status reflects the correct program state?

Unplug
  • 709
  • 10
  • 27

2 Answers2

1

BackgroundWorker uses the RunWorkerCompleted and the ReportProgress events to communicate back to the main thread. RunWorkerCompleted should do what you need to do as it will get executed on the UI thread as soon as the background work is complete.

        BackgroundWorker worker = new BackgroundWorker();

        worker.DoWork += delegate(object s, DoWorkEventArgs args)
        {
            LongComputation();
        };

        // RunWorkerCompleted will fire on the UI thread when the background process is complete
        worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
        {
            if (args.Error != null)
            {
                // an exception occurred on the background process, do some error handling
            }

            MyView.UpdateStatus("Ready");
        };

        MyView.UpdateStatus("Please wait");
        worker.RunWorkerAsync();

Additionally, you can use the RunWorkerCompleted to marshall results back to the main thread using the Result property of the DoWorkerEventArgs.

        worker.DoWork += delegate(object s, DoWorkEventArgs args)
        {
            args.Result = LongComputation();
        };

        worker.rep

        // RunWorkerCompleted will fire on the UI thread when the background process is complete
        worker.RunWorkerCompleted += delegate(object s, RunWorkerCompletedEventArgs args)
        {
            if (args.Error != null)
            {
                // an exception occurred on the background process, do some error handling
            }

            var result = args.Result;

            // do something on the UI with your result

            MyView.UpdateStatus("Ready");
        };

Finally, you can use the ReportProgress event you update your UI at logical steps in your background process:

        worker.DoWork += delegate(object s, DoWorkEventArgs args)
        {
            FirstHalfComputation();

            // you can report a percentage back to the UI thread, or you can send 
            // an object payload back
            int completedPercentage = 50;
            object state = new SomeObject();
            worker.ReportProgress(completedPercentage , state); 

            SecondHalfComputation();
        };

        worker.WorkerReportsProgress = true;    // this is important, defaults to false
        worker.ProgressChanged += delegate(object s, ProgressChangedEventArgs args)
        {
            int completedPercentage = args.ProgressPercentage;
            SomeObject state = args.UserState as SomeObject

            // update a progress bar or do whatever makes sense
            progressBar1.Step = completedPercentage;
            progressBar1.PerformStep();
        };
Jason
  • 651
  • 5
  • 10
  • Can I do ``MyWindowsForm newForm = new MyWindowsForm(args); newForm.Show()`` in a non-UI thread? – Unplug Nov 03 '13 at 04:09
  • I tried your suggestion, the newForm didn't pop up as I expected. When those two lines are not in a BackgroundWorker thread, it does show up with the line chart. – Unplug Nov 03 '13 at 04:15
  • Popping of the new forms should go in the RunWorkerCompleted. It is executed on the UI thread. If you need args from LongComputation (for the MyWindowsForm(args)), then pass it back to the RunWorkerCompleted using the DoWorkerEventArgs Result property. – Jason Nov 03 '13 at 04:45
  • Thank you Jason. I applied what you said and made my application work. I have a follow up question. What if I am calling a function in a reference that I don't have the source code and the function that takes a long time to generate a graph? I cannot use a BackgroundWorker because the function needs to be executed in the UI thread. – Unplug Nov 04 '13 at 16:28
  • Never mind. I use a Dispatcher.Invoke to update the status and set the priority to ``Send`` which is the highest priority. Although the user still needs to wait, at least she knows what's going on. – Unplug Nov 04 '13 at 19:23
0

I solved my problem with storing the Dispatcher from the main thread at Load of the form and then calling the dispatcher from the member-variable I stored it in from the BackgroundWorker thread:

Declaring member-variable at the beginning of the form:

Dispatcher mDispatcherMain = null;

Storing the dispatcher at the Load-function of the form:

mDispatcherMain = Dispatcher.CurrentDispatcher;

Invoking the main thread from the BackgroundWorker's DoWork-function:

mDispatcherMain.Invoke(new Action(() => { /* What you want to do */ }));
Christian Larsson
  • 141
  • 2
  • 5