BackgroundWorker Class Sample for Beginners
Introduction
This article presents a novice .NET developer to develop a multithreading application
without being burdened by the complexity that comes with threading.
Background
A basic Windows application runs on a single thread usually referred to as UI thread.
This UI thread is responsible for creating/painting all the controls and upon
which the code execution takes place. So when you are running a long-running task (i.e., data intensive database operation or processing some 100s of bitmap images), the UI thread locks
up and the UI application turns white (remember the UI thread was responsible
to paint all the controls) rendering your application to Not Responding state.
Using the Code
What you need to do is to shift this heavy processing on a different thread.
Leave the UI thread free for painting the UI. .NET has made the BackgroundWorker
object
available to us to simplify threading. This object is designed to simply run a
function on a different thread and then call an event on your UI thread when
it's complete.
The steps are extremely simple:
- Create a
BackgroundWorker
object. - Tell the
BackgroundWorker
object what task to run on the background thread (theDoWork
function). - Tell it what function to run on the UI thread when
the work is complete (theRunWorkerCompleted
function).
BackgroundWorker
uses the thread-pool,
which recycles threads to avoid recreating them for each new task. This means
one should never call Abort
on a BackgroundWorker
thread.
And a golden rule never to forget:
Never access UI objects on a thread that didn't create them. It means you cannot
use a code such as this...

Code
lblStatus.Text = "Processing file...20%";
...in the DoWork
function. Had you done
this, you would receive a runtime error. The BackgroundWorker
object resolves this problem by giving us a ReportProgress
function
which can be called from the background thread'sDoWork
function.
This will cause the ProgressChanged
event
to fire on the UI thread. Now we can access the UI objects on their thread and
do what we want (In our case, setting the label text status).
BackgroundWorker
also provides a RunWorkerCompleted
event
which fires after the DoWork
event handler has done its job. Handling RunWorkerCompleted
is
not mandatory, but one usually does so in order to query any exception that was thrown in DoWork
. Furthermore, code
within a RunWorkerCompleted
event handler is able to update Windows Forms and WPF controls without explicit marshalling;
code within the DoWork
event handler cannot.
To add support for progress reporting:
- Set the
WorkerReportsProgress
property
totrue
. - Periodically call
ReportProgress
from
within theDoWork
event handler with a "percentage complete" value.Collapse | Copy
Codem_oWorker.ReportProgress(i); //as seen in the code
- Handle the
ProgressChanged
event,
querying its event argument'sProgressPercentage
property:Collapse | Copy
Codevoid m_oWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
// This function fires on the UI thread so it's safe to edit
// the UI control directly, no funny business with Control.Invoke :)
// Update the progressBar with the integer supplied to us from the
// ReportProgress() function.
progressBar1.Value = e.ProgressPercentage;
lblStatus.Text = "Processing......" + progressBar1.Value.ToString() + "%";
}
Code in the ProgressChanged
event
handler is free to interact with UI controls just as with RunWorkerCompleted
. This is typically where you will update
a progress bar.
To add support for cancellation:
- Set the
WorkerSupportsCancellation
property totrue
. - Periodically check the
CancellationPending
property from within theDoWork
event
handler – iftrue
, set the event argument'sCancel
property
totrue
, and return. (The worker can setCancel
and exit without prompting via
trueCancellationPending
– if it decides the job's too difficult and it can't
go on).Collapse | Copy
Codeif (m_oWorker.CancellationPending)
{
// Set the e.Cancel flag so that the WorkerCompleted event
// knows that the process was cancelled.
e.Cancel = true;
m_oWorker.ReportProgress(0);
return;
} - Call
CancelAsync
to request cancellation. This code is handled on click
of the Cancel button.Collapse | Copy
Codem_oWorker.CancelAsync();
Properties
This is not an exhaustive list, but I want to emphasize the Argument
, Result
,
and the RunWorkerAsync
methods. These are properties of BackgroundWorker
that
you absolutely need to know to accomplish anything. I show the properties as you would reference them in your code.
DoWorkEventArgs
Usage: Contains
ee.Argument
ande.Result
,
so it is used to access those properties.e.Argument
Usage: Used to get the parameter reference received byRunWorkerAsync
.e.Result
Usage:
Check to see what theBackgroundWorker
processing did.m_oWorker.RunWorkerAsync();
Usage:
Called to start a process on the worker thread.
Here's the entire code:

Code
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Threading;
using System.Text;
using System.Windows.Forms; namespace BackgroundWorkerSample
{
// The BackgroundWorker will be used to perform a long running action
// on a background thread. This allows the UI to be free for painting
// as well as other actions the user may want to perform. The background
// thread will use the ReportProgress event to update the ProgressBar
// on the UI thread.
public partial class Form1 : Form
{
/// <summary>
/// The backgroundworker object on which the time consuming operation
/// shall be executed
/// </summary>
BackgroundWorker m_oWorker; public Form1()
{
InitializeComponent();
m_oWorker = new BackgroundWorker(); // Create a background worker thread that ReportsProgress &
// SupportsCancellation
// Hook up the appropriate events.
m_oWorker.DoWork += new DoWorkEventHandler(m_oWorker_DoWork);
m_oWorker.ProgressChanged += new ProgressChangedEventHandler
(m_oWorker_ProgressChanged);
m_oWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler
(m_oWorker_RunWorkerCompleted);
m_oWorker.WorkerReportsProgress = true;
m_oWorker.WorkerSupportsCancellation = true;
} /// <summary>
/// On completed do the appropriate task
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void m_oWorker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
// The background process is complete. We need to inspect
// our response to see if an error occurred, a cancel was
// requested or if we completed successfully.
if (e.Cancelled)
{
lblStatus.Text = "Task Cancelled.";
} // Check to see if an error occurred in the background process. else if (e.Error != null)
{
lblStatus.Text = "Error while performing background operation.";
}
else
{
// Everything completed normally.
lblStatus.Text = "Task Completed...";
} //Change the status of the buttons on the UI accordingly
btnStartAsyncOperation.Enabled = true;
btnCancel.Enabled = false;
} /// <summary>
/// Notification is performed here to the progress bar
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void m_oWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
{ // This function fires on the UI thread so it's safe to edit // the UI control directly, no funny business with Control.Invoke :) // Update the progressBar with the integer supplied to us from the // ReportProgress() function. progressBar1.Value = e.ProgressPercentage;
lblStatus.Text = "Processing......" + progressBar1.Value.ToString() + "%";
} /// <summary>
/// Time consuming operations go here </br>
/// i.e. Database operations,Reporting
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void m_oWorker_DoWork(object sender, DoWorkEventArgs e)
{
// The sender is the BackgroundWorker object we need it to
// report progress and check for cancellation.
//NOTE : Never play with the UI thread here...
for (int i = 0; i < 100; i++)
{
Thread.Sleep(100); // Periodically report progress to the main thread so that it can
// update the UI. In most cases you'll just need to send an
// integer that will update a ProgressBar
m_oWorker.ReportProgress(i);
// Periodically check if a cancellation request is pending.
// If the user clicks cancel the line
// m_AsyncWorker.CancelAsync(); if ran above. This
// sets the CancellationPending to true.
// You must check this flag in here and react to it.
// We react to it by setting e.Cancel to true and leaving
if (m_oWorker.CancellationPending)
{
// Set the e.Cancel flag so that the WorkerCompleted event
// knows that the process was cancelled.
e.Cancel = true;
m_oWorker.ReportProgress(0);
return;
}
} //Report 100% completion on operation completed
m_oWorker.ReportProgress(100);
} private void btnStartAsyncOperation_Click(object sender, EventArgs e)
{
//Change the status of the buttons on the UI accordingly
//The start button is disabled as soon as the background operation is started
//The Cancel button is enabled so that the user can stop the operation
//at any point of time during the execution
btnStartAsyncOperation.Enabled = false;
btnCancel.Enabled = true; // Kickoff the worker thread to begin it's DoWork function.
m_oWorker.RunWorkerAsync();
} private void btnCancel_Click(object sender, EventArgs e)
{
if (m_oWorker.IsBusy)
{ // Notify the worker thread that a cancel has been requested. // The cancel will not actually happen until the thread in the // DoWork checks the m_oWorker.CancellationPending flag. m_oWorker.CancelAsync();
}
}
}
}
1. Start
Once the application is started, click on the button that reads Start Asynchronous Operation. The UI now shows aprogressbar
with UI continuously being updated.
2. Cancel
To cancel the parallel operation midway, press the cancel button. Note that the UI thread is
now free to perform any additional task during this time and it is not locked by the data intensive operation that is happening in the background.
3. On Successful Completion
The statusbar shall read Task Completed upon the successful completion of the parallel task.
Points of Interest
转自:http://www.codeproject.com/Articles/99143/BackgroundWorker-Class-Sample-for-Beginners
BackgroundWorker Class Sample for Beginners的更多相关文章
- Multithreading annd Grand Central Dispatch on ios for Beginners Tutorial-多线程和GCD的入门教程
原文链接:Multithreading and Grand Central Dispatch on iOS for Beginners Tutorial Have you ever written a ...
- TSQL Beginners Challenge 3 - Find the Factorial
这是一个关于CTE的应用,这里我们用CTE实现阶乘 Factorial,首先来看一个简单的小实验,然后再来看题目.有的童鞋会问怎么没有2就来3了呢,惭愧,TSQL Beginners Challeng ...
- GDI+ Tutorial for Beginners
原文 GDI+ Tutorial for Beginners GDI+ is next evolution of GDI. Using GDI objects in earlier versions ...
- ObjectARX® for Beginners: An Introduction
转:ObjectARX® for Beginners: An Introduction Lee Ambrosius – Autodesk, Inc. CP4164-L Objec ...
- BackgroundWorker study
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usin ...
- C# BackgroundWorker 详解
在C#程序中,经常会有一些耗时较长的CPU密集型运算,如果直接在 UI 线程执行这样的运算就会出现UI不响应的问题.解决这类问题的主要途径是使用多线程,启动一个后台线程,把运算操作放在这个后台线程中完 ...
- Linux下UPnP sample分析
一.UPnP简介 UPnP(Universal Plug and Play)技术是一种屏蔽各种数字设备的硬件和操作系统的通信协议.它是一种数字网络中间件技术,建立在TCP/IP.HTTP协 ...
- 【Winform】使用BackgroundWorker控制进度条显示进度
许多开发者看见一些软件有进度条显示进度,自己想弄,项目建好后发现并没有自己想象中的那么简单...看了网上很多教程后,写了一个小Demo供网友们参考~~,Demo的网址:http://pan.baidu ...
- cocos2d-x for android配置 & 运行 Sample on Linux OS
1.从http://www.cocos2d-x.org/download下载稳定版 比如cocos2d-x-2.2 2.解压cocos2d-x-2.2.zip,比如本文将其解压到 /opt 目录下 3 ...
随机推荐
- DevExpress ASP.NET Core Controls v18.2新功能详解
行业领先的.NET界面控件2018年第二次重大更新——DevExpress v18.2日前正式发布,本站将以连载的形式为大家介绍新版本新功能.本文将介绍了DevExpress ASP.NET Core ...
- php +apache +mysql 配置笔记
2013年11月5日 14:27:46 php +apache +mysql 配置笔记 mysql 正常安装 忽略. 1,配置笔记:安装apache 的成功标志是:安装完成之后,在浏览器输入http: ...
- url中特殊符号转换
特殊符号 url中显示 空格 %20 & %26
- L300 3月英语课下
重音 句中的实词(内容词)要被重读,读得重.长一点.句中的虚词(功能词)要被轻读或弱读,读得轻.短一点口语交流中,当虚词的在句中起到重要的表意作用时,会被重读. 连读 连读:把一个单词的尾音同下一个单 ...
- c# 中foreach 循环
使用foreach循环可以迭代数组或一个集合对象, 1.通过foreach 循环输出整型数组中的数组: 2.通过for循环输出整型数组中的元素: 3.foreach 循环设置数组元素的计算器: cla ...
- 如何实时查看Linux下日志
以下以Tomcat为例子,其他WEB服务器目录自己灵活修改即可: 1.先切换到:cd usr/local/tomcat5/logs2.tail -f catalina.out3.这样运行时就可以实时查 ...
- Python库,让你相见恨晚的第三方库
环境管理 管理 Python 版本和环境的工具 p – 非常简单的交互式 python 版本管理工具.pyenv – 简单的 Python 版本管理工具.Vex – 可以在虚拟环境中执行命令.virt ...
- java学习笔记19(Arrays类)
Arrays类: 此类包含用来操作数组的各种方法(比如升序和搜索): import java.util.Arrays; public class Demo { public static void m ...
- scp 脚本
#!/bin/bash ty=$ local_dir=$ remote_ip=$ remote_dir=$ showUsage() { echo -e "\033[31m ty local_ ...
- TEST mathjax
这里是第一个公式 $ F = ma^2 $ \[ \text{Reinforcement Learning} \doteq \pi_* \\ \quad \updownarrow \\ \pi_* \ ...