多个后台线程

Question

I have one c# application that uses BackGroundWorker to do a group of tasks:

 private void buttonStartCheckOut_Click(object sender, EventArgs e)
        {
                BackgroundWorker checkOuter = new BackgroundWorker();
                checkOuter.DoWork += new DoWorkEventHandler(checkOuter_DoWork);
                checkOuter.RunWorkerAsync();
                checkOuter.RunWorkerCompleted += new RunWorkerCompletedEventHandler(checkOuter_RunWorkerCompleted);
            }

        void checkOuter_DoWork(object sender, DoWorkEventArgs e)
        {
            if (textBoxCICheckOut.Text != "")
                CheckOutCI();

            if (textBoxCACheckOut.Text != "")
                CheckOutCA();

            if (textBoxCAuthCheckOut.Text != "")
                CheckOutCAuth();

            if (textBoxCLCheckOut.Text != "")
                CheckOutCL();

            if (textBoxCCCheckOut.Text != "")
                CheckOutCC();
        }

As you can see, I have only 2 threads; one for GUI and one for secondary task.
Its easy for me to track when all the functions finish.
Now I want to make it more fast by creating a separate thread for CheckOutCI(), CheckOutCA() and others.Creating 5 background workers looks kinda dirty.

I want to ask:
How will I keep track of when all the functions have finished executing.

If any one function returned an exception, I want to display it to user and ask the user to correct the user and try again. I hope I am able to explain my question properly.
PLEASE edit the code by wdavo as per my comment on his post.

Answer 1

I'd look at using the Task library (Assuming you are running .NET 4.5 or later). I find it much better to use than background workers in most cases.

(Note you can still use the Task library in .NET 4, however Task.WhenAll is only available in 4.5)

http://msdn.microsoft.com/en-us/library/dd235618

Without rewriting your whole program, here's an example of how you would use it:

Move your simple conditional logic to the button

private void button1_Click(object sender, EventArgs e)
{
  var tasks = new List<Task>();

  if (Text == "A")
  {
    tasks.Add(funcA());
  }

  if (Text == "B")
  {
    tasks.Add(funcB());
  }

  //And so on....

  Task.WhenAll(tasks.ToArray()).ContinueWith(t =>
  {
    if (t.Exception != null)
    {
      //One of the tasks threw an exception
      MessageBox.Show("There was an exception!");
    }
    else
    {
      //None of the tasks threw an exception
      MessageBox.Show("No Exceptions!");
    }
  });

}

We add the tasks to a collection so we can know when they all finish via Task.WhenAll. When all the tasks in the collection have finished, a message box will be displayed. If any of the tasks in the collection have thrown an exception, the Exception property of 't' will be populated. The specific exceptions exist as inner exceptions of this exception.

Move your threading code to individual task/functions. You'd create your checkout functions to look similar to this:

private Task funcA()
{
  return Task.Factory.StartNew(() =>
  {
    try
    {
      //Code running here will be executed on another thread
      //This is where you would put your time consuming work
      //
      //
    }
    catch(Exception ex)
    {
      //Handle any exception locally if needed
      //If you do handle it locally, make sure you throw it again so we can see it in Task.WhenAll
      throw ex;
    }

    //Do any required UI updates after the work
    //We aren't on the UI thread, so you will need to use BeginInvoke
    //'this' would be a reference to your form
    this.BeginInvoke(new Action(() =>
    {
      //...
    }));

  });
}

What this does is the following

• Creates a and runs a task which does some work on a thread from the thread pool
• If there is an exception, we handle it locally .We re-throw the exception so that we can know that a task has failed when 'Task.WhenAll' is executed
• Updates the UI after the work is done. You need to call BeginInvoke to run the code on the UI thread to avoid cross threading issues.

Answer 2

Starting up more threads than CPUs or cores can actually make your application slower. When there are more CPU-bound threads than CPUs the OS needs to context switch more often between the threads--which is hugely expensive and could result in the OS spending more time context switching between your threads than giving them time to work.

You can use the parallel aspect of the Parallel Task Library to automatically distribute your load across CPUs. For example:

Action[] actions = new Action[] {CheckOutCI, CheckOutCA, CheckOutCAuth, CheckOutCL, CheckOutCC};
Parallel.ForEach(actions, e=>e());

...which isn't exactly what you want; but should give you a general idea. eg populate actions based on current conditions.

Answer 3

You need to use ReportProgress method in backgroundworker

void checkOuter_DoWork(object sender, DoWorkEventArgs e)
    {
        if (textBoxCICheckOut.Text != "")
            CheckOutCI();
            checkOuter.ReportProgress(completionPercentage,"Error message");

The data sent in ReportProgress can be captured in checkOuter_ProgressChanged event

 checkOuter_ProgressChanged(object sender,ProgressChangedEventArgs e)
 {
     int percentage = e.ProgressPercentage;
     string message = e.UserState;
 }