BackgroundWorker In C#

If you look at the Component Tab of your Visual Studio Toolbox of Visual Studio 2010, you will notice that the BackgroundWorker component is the first in the list. If you have ever written multi-threaded applications, you must be familiar with the primary and worker or secondary threads. A primary thread is the default, main thread of an application and executes the default execution path. 
We often use background threads when a time-consuming process needed to be executed in the background without affecting the responsiveness of the user interface. This is where a BackgroundWorker component comes into play. If you are not familiar with the multi-threaded application, visit our Multithreading Programming using C# section where you can find many articles and tutorials.
A BackgroundWorker component executes code in a separate dedicated secondary thread. In this article, I will demonstrate how to use the BackgroundWorker component to execute a time-consuming process while the main thread is still available to the user interface.

Creating a BackgroundWorker

We can create a BackgroundWorker at design-time by dragging onto a Form or at run-time using the BackgroundWorker class.
The following code is added when you drag a BackgroundWorker component onto a Form.
  1. private System.ComponentModel.BackgroundWorker backgroundWorker1;  
  2. this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();  

BackgroundWorker Properties

Here is a list of BackgroundWorker class properties.
  • CancellationPending - Indicates if an application has requested cancellation of a BackgroundWorker.
  • IsBusy - Indicates if a BackgroundWorker is running an asynchronous operation.
  • WorkerReportsProgress - Indicates of a BackgroundWorker can report progress updates.
  • WorkerSupportsCancellation - Indicates if a BackgroundWorker supports asynchronous cancellation.

BackgroundWorker Methods

BackgroundWorker has two methods, RunWorkerAsync and CancelAsync. The RunWorkerAsync starts the thread and the CancelAsync stops the thread.

BackgroundWorker Events

DoWork event is the starting point for a BackgroundWorker. This event is fired when the RunWorkerAsync method is called. In this event hander, we call our code that is being processed in the background where our application is still doing some other work.
  1. this.backgroundWorker1.DoWork += new System.ComponentModel.DoWorkEventHandler(this.backgroundWorker1_DoWork);  
The DoWork event handler looks like this where we need to call our time-consuming method.
  1. private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)  
  2. {  
  3.    BackgroundProcessLogicMethod();  
  4. }  
ProgressChanged event occurs when ReportProgress is called. RunWorkerCompleted event occurs when the background operation has completed.

BackgroundWorker Example

Now we are going to create a sample application. The user interface looks like Figure 1 where a Form has two Button controls and a RichTextBox control. While BackgroundWorker will be doing some background work, the user can still type in the RichTextBox. 

Figure 1

Start button click starts the processing BackgroundWorker and Stop button click stops the processing. While BackgroundWorker is doing work in the background, you may still type anything in the RichTextBox control.

The Start and Stop button click event handlers look like this.
  1. private void StartButton_Click(object sender, EventArgs e)
  2. {
  3.    // Start BackgroundWorker
  4.    backgroundWorker1.RunWorkerAsync(2000);
  5. }
  7. private void StopButton_Click(object sender, EventArgs e)
  8. {
  9.    // Cancel BackgroundWorker
  10.    if (!backgroundWorker1.IsBusy)
  11.    backgroundWorker1.CancelAsync();
  12. }  
And, here is the code for the DoWork event, background worker method, and WorkerCompleted event.
  1. private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {  
  2.     BackgroundWorker helperBW = sender as BackgroundWorker;  
  3.     int arg = (int) e.Argument;  
  4.     e.Result = BackgroundProcessLogicMethod(helperBW, arg);  
  5.     if (helperBW.CancellationPending) {  
  6.         e.Cancel = true;  
  7.     }  
  8. }  
  9. // Put all of background logic that is taking too much time      
  10. private int BackgroundProcessLogicMethod(BackgroundWorker bw, int a) {  
  11.     int result = 0;  
  12.     Thread.Sleep(20000);  
  13.     MessageBox.Show("I was doing some work in the background.");  
  14.     return result;  
  15. }  
  16. private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) {  
  17.     if (e.Cancelled) MessageBox.Show("Operation was canceled");  
  18.     else if (e.Error != null) MessageBox.Show(e.Error.Message);  
  19.     else MessageBox.Show(e.Result.ToString());  
  20. }  


In this article, we discussed how to create a BackgroundWorker in a Windows Forms application and run a process in the background while UI is still responsive and available to the user.

Further Readings

Founded in 2003, Mindcracker is the authority in custom software development and innovation. We put best practices into action. We deliver solutions based on consumer and industry analysis.