【转载于百度空间】C# WinForm中的BackgroundWorker控件的使用方法

C# BackgroundWorker 使用方法

MSDN解析网址：

msdn.microsoft.com/zh-cn/library/system.componentmodel.backgroundworker(VS.80).aspx

BackgroundWorker 类允许您在单独的专用线程上运行操作。

耗时的操作（如下载和数据库事务）在长时间运行时可能会导致用户界面 (UI) 似乎处于停止响应状态。

如果您需要能进行响应的用户界面，而且面临与这类操作相关的长时间延迟，则可以使用 BackgroundWorker 类方便地解决问题。

若要在后台执行耗时的操作，请创建一个 BackgroundWorker，侦听那些报告操作进度并在操作完成时发出信号的事件。可以通过编程方式创建 BackgroundWorker，也可以将它从“工具箱”的“组件”选项卡中拖到窗体上。

如果在 Windows 窗体设计器中创建 BackgroundWorker，则它会出现在组件栏中，而且它的属性会显示在“属性”窗口中。

若要设置后台操作，请为 DoWork 事件添加一个事件处理程序。

在此事件处理程序中调用耗时的操作。若要启动该操作，请调用 RunWorkerAsync。

若要收到进度更新通知，请对 ProgressChanged 事件进行处理。

若要在操作完成时收到通知，请对 RunWorkerCompleted 事件进行处理。

下面代码演示如何用BackgroundWorker计算斐波那契数列并表示当前进度

/////////////////////////////Form1.cs///////////////////////////////

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace WindowsApplication2
{
    public partial class Form1 : Form
    {
        private int numberToCompute = 0;
        private int highestPercentageReached = 0;
        public Form1()
        {
            InitializeComponent();
            InitializeBackgoundWorker();
        }

        // Set up the BackgroundWorker object by 
        // attaching event handlers. 

        private void InitializeBackgoundWorker()
        {
            backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);
            backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);
            backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);
        }
        private void startAsyncButton_Click(System.Object sender, System.EventArgs e)
        {
            // Reset the text in the result label.
            resultLabel.Text = String.Empty;

            // Disable the UpDown control until 
            // the asynchronous operation is done.
            this.numericUpDown1.Enabled = false;

            // Disable the Start button until 
            // the asynchronous operation is done.
            this.startAsyncButton.Enabled = false;

            // Enable the Cancel button while 
            // the asynchronous operation runs.
            this.cancelAsyncButton.Enabled = true;

            // Get the value from the UpDown control.
            numberToCompute = (int)numericUpDown1.Value;

            // Reset the variable for percentage tracking.
            highestPercentageReached = 0;

            // Start the asynchronous operation.
            backgroundWorker1.RunWorkerAsync(numberToCompute);
        }
        private void cancelAsyncButton_Click(System.Object sender, System.EventArgs e)
        {
            // Cancel the asynchronous operation.
            this.backgroundWorker1.CancelAsync();
            // Disable the Cancel button.
            cancelAsyncButton.Enabled = false;
        }
        // This event handler is where the actual,
        // potentially time-consuming work is done.
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            // Get the BackgroundWorker that raised this event.
            BackgroundWorker worker = sender as BackgroundWorker;
            // Assign the result of the computation
            // to the Result property of the DoWorkEventArgs
            // object. This is will be available to the 
            // RunWorkerCompleted eventhandler.
            e.Result = ComputeFibonacci((int)e.Argument, worker, e);
        }

        // This event handler deals with the results of the
        // background operation.
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            // First, handle the case where an exception was thrown.
            if (e.Error != null)
            {
                MessageBox.Show(e.Error.Message);
            }
            else if (e.Cancelled)
            {
                // Next, handle the case where the user canceled 
                // the operation.
                // Note that due to a race condition in 
                // the DoWork event handler, the Cancelled
                // flag may not have been set, even though
                // CancelAsync was called.
                resultLabel.Text = "Canceled";
            }
            else
            {
                // Finally, handle the case where the operation 
                // succeeded.
                resultLabel.Text = e.Result.ToString();
            }
            // Enable the UpDown control.
            this.numericUpDown1.Enabled = true;
            // Enable the Start button.
            startAsyncButton.Enabled = true;
            // Disable the Cancel button.
            cancelAsyncButton.Enabled = false;
        }
        // This event handler updates the progress bar.
        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.progressBar1.Value = e.ProgressPercentage;
        }

        // This is the method that does the actual work. For this
        // example, it computes a Fibonacci number and
        // reports progress as it does its work.
        long ComputeFibonacci(int n, BackgroundWorker worker, DoWorkEventArgs e)
        {
            // The parameter n must be >= 0 and <= 91.
            // Fib(n), with n > 91, overflows a long.
            if ((n < 0) || (n > 91))
            {
                throw new ArgumentException("value must be >= 0 and <= 91", "n");
            }
            long result = 0;

            // Abort the operation if the user has canceled.
            // Note that a call to CancelAsync may have set 
            // CancellationPending to true just after the
            // last invocation of this method exits, so this 
            // code will not have the opportunity to set the 
            // DoWorkEventArgs.Cancel flag to true. This means
            // that RunWorkerCompletedEventArgs.Cancelled will
            // not be set to true in your RunWorkerCompleted
            // event handler. This is a race condition.
            if (worker.CancellationPending)
            {
                e.Cancel = true;
            }
            else
            {
                if (n < 2)
                {
                    result = 1;
                }
                else
                {
                    result = ComputeFibonacci(n - 1, worker, e) + ComputeFibonacci(n - 2, worker, e);
                }

                // Report progress as a percentage of the total task.
                int percentComplete = (int)((float)n / (float)numberToCompute * 100);
                if (percentComplete > highestPercentageReached)
                {
                    highestPercentageReached = percentComplete;
                    worker.ReportProgress(percentComplete);
                }
            }
            return result;
        }
    }
}

《《《《《《《《《《《《《《《《《《《《《《《《《

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

用 BackgroundWorker 类执行耗时的操作

BackgroundWorker 类在 System.ComponentModel 命名空间下。

VS 的工具箱时有一个 BackgroundWorker 组件，就是这个类。

常用方法

1.RunWorkerAsync

开始执行后台操作。引发 DoWork 事件

2.CancelAsync

请求取消挂起的后台操作。

注意：这个方法是将 CancellationPending 属性设置为 true，并不会终止后台操作。在后台操作中要检查 CancellationPending 属性，来决定是否要继续执行耗时的操作。

3.ReportProgress

引发 ProgressChanged 事件。

常用属性

1.CancellationPending

指示应用程序是否已请求取消后台操作。

只读属性，默认为 false，当执行了 CancelAsync 方法后，值为 true。

2.WorkerSupportsCancellation

指示是否支持异步取消。要执行 CancelAsync 方法，需要先设置该属性为 true。

3.WorkerReportsProgress

指示是否能报告进度。要执行 ReportProgress 方法，需要先设置该属性为 true。

常用事件

1.DoWork

调用 RunWorkerAsync 方法时发生。

2.RunWorkerCompleted

后台操作已完成、被取消或引发异常时发生。

3.ProgressChanged

调用 ReportProgress 方法时发生。

在 DoWork 事件处理程序中不操作任何用户界面对象。而应该通过 ProgressChanged 和 RunWorkerCompleted 事件与用户界面进行通信。

如果想在 DoWork 事件处理程序中和用户界面的控件通信，可在用 ReportProgress 方法。

ReportProgress(int percentProgress, object userState)，可以传递一个对象。

ProgressChanged 事件可以从参数 ProgressChangedEventArgs 类的 UserState 属性得到这个信息对象。

简单的程序用 BackgroundWorker 比 Thread 方便，Thread 中和用户界面上的控件通信比较麻烦，需要用委托来调用控件的 Invoke 或 BeginInvoke 方法，没有 BackgroundWorker 方便。

============================

一个简单的刷网页流量的小工具代码

1. 从工具栏拖一个BackgroundWorker控件，设置其属性WorkerReportsProgress为true

2. 要让worker开始工作，执行如下代码：

mBackgroundWorker.RunWorkerAsync(arg);

这里有重写，如果不需要传递参数直接mBackgroundWorker.RunWorkerAsync();

3. 编辑DoWork事件代码：

e.Argument为mBackgroundWorker.RunWorkerAsync(arg);对应的参数

之所以使用进度条，肯定是有循环的，在循环中报告进度：

worker.ReportProgress(i * 100 / totalNum, obj );

其中第一个参数是当前进度的百分之多少，obj为你要传递的UserState，如果没有可以不要

4. 编辑ProgressChanged事件代码：

e.ProgressPercentage为进度的百分数，e.UserState为刚才传递过来的object

在这个事件中可以调用ui的进度条和其他控件：

mToolStripProgressBar.Value = e.ProgressPercentage;

5. 编辑RunWorkerCompleted事件代码：

工作完成了告诉ui

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using System.Net;

using System.Threading;

namespace WindowsApplication15

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

private void button1_Click(object sender, EventArgs e)

{

//textBox1.Text里面储存URL

backgroundWorker1.RunWorkerAsync(textBox1.Text);

}

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)

{

BackgroundWorker bw = (BackgroundWorker)sender;

string url = e.Argument.ToString();

for (int i = 0; i < 10; i++)

{

//没有取消后台操作

if (!bw.CancellationPending)

{

WebRequest req = WebRequest.Create(url);

WebResponse resp = req.GetResponse();

resp.Close();

Thread.Sleep(1000);

bw.ReportProgress(i * 100 / 10, i);

}

}

}

private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)

{

progressBar1.Value = e.ProgressPercentage;

label1.Text = e.UserState.ToString();

}

private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)

{

MessageBox.Show("ok！");

}

}

}