C# Background Worker Tutorial

2/21/2014 C# BackgroundWorker Tutorial

http://www.dotnetperls.com/backgroundworker 1/12

C# BackgroundWorker

BackgroundWorker makes

threads easy to implement in

Windows Forms. Intensive tasks

need to be done on another thread

so the UI does not freeze. It is

necessary to post messages and

update the user interface when the

task is done.

Thread

StepsIn the image, you see the Visual

Studio designer view. The fly-out

panel is the Toolboxit contains

links for all kinds of controls. It also contains the

BackgroundWorker link, which we can use in the following steps.

First, click on BackgroundWorker. You

will need to double-click on

BackgroundWorker link in the Toolbox.

Look at the gray bar near the bottom of

your window. A BackgroundWorker will

appear there.

Go

C#: Windows



Second:

Highlight backgroundWorker1. Click on the

backgroundWorker1 item in the gray bar on the bottom. Now,

look at the Properties panel.

Third:

Look for the lightning bolt.

You will see a lightning bolt icon in the Properties pane.

This is Microsoft's icon for events.

Tip:

BackgroundWorker is event-driven, so this is where we will

make the necessary events to use it.

Then, double-click on DoWork. Sorry, but we have to begin

working. Double-click on DoWork, which will tell Visual Studio to

make a new "work" method. In this method, you will put the

important, processor-intensive stuff.

Windows Forms

C# Visual Studio

VB Net



The rectangles show the tray at the bottom

containing the backgroundWorker1 icon, and

the Properties panel on the right. The lightning

bolt helps us easily add events to the

BackgroundWorker.

Tip:

This UI is far better than trying to type the methods in

manually. It requires less effort on your part.



DoWorkThe DoWork method is like any other event

handler. Here we must look at the C# view

of your file, where we will see the DoWork

method. You should see that the

backgroundWorker1_DoWork event is

generated when you double-click on DoWork.

For testing, let's add a Thread.Sleep

command there. The Thread.Sleep method will pause the

execution of the BackgroundWorker, but does not consume the

entire CPU. It will show us threading is functioning.

Sleep

Example that shows DoWork event handler: C#

using System;using System.ComponentModel;using System.Windows.Forms;using System.Threading;

namespace WindowsFormsApplication1{ public partial class Form1 : Form { public Form1() { InitializeComponent(); }

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e) {



Thread.Sleep(1000); // One second. } }

}

PropertiesI want to emphasize the

Argument, Result, and the

RunWorkerAsync methods. These

are the properties of

BackgroundWorker required to

accomplish anything. I show the

properties as you would reference

them in your code.

BackgroundWorker property list: C#

DoWorkEventArgs e Contains e.Argument and e.Result. It is used to access those properties.

e.Argument Used to get the parameter reference received by RunWorkerAsync.

e.Result Check to see what the BackgroundWorker processing did.

backgroundWorker1.RunWorkerAsync Called to start a process on the worker thread.

RunWorkerAsync



We can add instructions to the

BackgroundWorker by adding

arguments and return values. We need

to add arguments, invoke the

BackgroundWorker, and then receive

the results of the thread.

Tip:

Changing variables from multiple threads at once often leads

to bugs. A variable can become invalid.

Example that shows RunWorkerAsync call: C#

public partial class Form1 : Form{ public Form1() { InitializeComponent();

// // Example argument object // TestObject test = new TestObject { OneValue = 5, TwoValue = 4 }; // // Send argument to our worker thread // backgroundWorker1.RunWorkerAsync(test); }}



/// /// The test class for our example./// class TestObject{ public int OneValue { get; set; } public int TwoValue { get; set; }}

An example argument is created. TestObject

in the above code is an example object. You will

have something more important and complex in

your program. The syntax above is just C#

collection initializer syntax.

Tip:

RunWorkerAsync can be called anywhere in

your code. We use a constructor, but that isn't important.

DoWork 2You can implement DoWork by

putting your expensive code in it.

Then, use the DoWorkEventArgs in its

body and as its result. Here we hook

up the arguments and results from

the RunWorkerAsync call.

Note:

The TestObject was passed to RunWorkerAsync, and that is

received as e.Argument. We also have to cast.



Example that implements DoWork: C#

/// /// Where we do the work in the program (the expensive slow stuff)./// private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e){ // // e.Argument always contains whatever was sent to the background worker // in RunWorkerAsync. We can simply cast it to its original type. // TestObject argumentTest = e.Argument as TestObject;

// // Boring.... // Thread.Sleep(10000);

argumentTest.OneValue = 6; argumentTest.TwoValue = 3;

// // Now, return the values we generated in this method. // ... Use e.Result. // e.Result = argumentTest;}

RunWorkerCompletedYou can use the RunWorkerCompleted event

handler by going to the lightning bolt in the

designer and clicking on the backgroundWorker1

icon in the tray. Now double-click in

RunWorkerCompleted.



Next:

You will get some autogenerated code that looks just like this.

Put the argument receiving code in this method.

Example that shows RunWorkerCompleted event handler: C#

/// /// This is on the main thread, so we can update a TextBox or anything./// private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e){ // // Receive the result from DoWork, and display it. // TestObject test = e.Result as TestObject; this.Text = test.OneValue.ToString() + " " + test.TwoValue.ToString();

// // Will display "6 3" in title Text (in this example) //}

DiscussionYou probably know more than you

think about the BackgroundWorker

class. BackgroundWorker has a name

that might indicate it is more complex

than it really is. There are many more

details about threading and abort

calls.



However:

Once you understand that BackgroundWorker is just a

structural overlay to threads in Windows Forms, it is intuitive.

First, call RunWorkerAsync with an

argument. You can pass any

argument to this method on

BackgroundWorker, including null. It

simply must inherit from object,

which everything does.

Second:

Custom processing is run.

Your expensive code is executed

in the DoWork method.

Insert pause here as your

program works.

Third:

It finishes.

When your processing is done, RunWorkerCompleted is called.

In this method, you receive the result.

ProgressBarA ProgressBar visually displays progress. And the ProgressBar

control in Windows Forms can be used with a BackgroundWorker.

This site has a detailed tutorial on how to use these controls

together.



ProgressBar

Also:

The WPF ProgressBar is

covered.

It too can be used with a

BackgroundWorker control.

ProgressBar

SummaryWe implemented the code for a

BackgroundWorker control. We

generally instead prefer ThreadPool

when we need many threads. And

threads are not always useful. IO

operations, for example, cannot

always be multithreaded well.

Thus:

With the era of multiple processor systems, we need threads.

And BackgroundWorker is an excellent shortcut.

C# Testing

C# Programming Tutorial

Test C# Code



C# Forumwww.daniweb.com

Free Answers to Your Programming Questions from our Savvy Community

C# Background Worker Tutorial

Documents

Transcript of C# Background Worker Tutorial