BackgroundWorker简单实用（易于异步操作）

Microsoft提供了一个帮助程序类BackgroundWorker，该类可以快速使用多线程，该线程可以程完成后快速创建新线程，报告进度backgroundworker 线程操作无效，暂停和处理其他任务.

1. BackgroundWorker类简介1.1. 四个常见属性:

public bool IsBusy {get;} //只读属性，用于确定当前线程是否正在工作

public bool WorkerReportsProgress {get; set;} //确定当前线程是否可以报告进度

public bool WorkerSupportsCancellation {get; set;} //确定是否可以取消当前线程

public bool CancellationPending {get;} //只读属性，用于确定是否发送了线程取消消息（当调用CancelAsync（）方法时，它设置为true）

1.2. 三个常见事件:

公共事件DoWorkEventHandler DoWork; //必须启动，线程的主要逻辑，在调用RunWorkerAsync（）时触发该事件

公共事件ProgressChangedEventHandler ProgressChanged; //报告可选，报告进度事件，该事件在调用ReportProgress（）时触发

公共事件RunWorkerCompletedEventHandler RunWorkerCompleted; //结束可选，该事件将程完成运行，发生异常并调用CancelAsync（）方法时触发.

1.3. 三种常用方法:

public void RunWorkerAsync（）; //启动线程，触发DoWork事件

public void RunWorkerAsync（object arguments）;

public void ReportProgress（int percentProgress）; //报告进度，触发ProgressChanged事件

public void ReportProgress（int percentProgress，object userState）;

public void CancelAsync（）; //取消线程，将CancellationPending设置为true

2.BackgroundWorker的用法2.1. 简单用法:

创建BackgroundWorder对象；

根据要求，设置是否取消（WorkerSupportsCancellation）和是否报告进度（WorkerReportsProgress）；

根据要求，设置相关事件DoWorker，ProgressChanged，ProgressChanged；

调用RunWorkerAsyns（）方法启动线程；

在需要取消的位置，判断CancellationPending的值并进行相关处理； //可选

在适当的位置调用ReportProgress（int percentProgress）方法以报告进度.

2.2. 简单示例: 2.2.1. 最基本的运行代码

界面的简单代码:

界面上有一个Grid控件和2个按钮

 1 <Window x:Class="BackgroundWorkerDemo20170324.MainWindow"
 2         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
 3         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
 4         Title="MainWindow" Height="342" Width="504">
 5     <Grid>
 6         <ProgressBar x:Name="pBar" Margin="50,69,43,209">
 7         ProgressBar>
 8         <Button x:Name="btnStart" Content="start" Click="btnStart_Click" Margin="50,218,311,63"/>
 9         <Button x:Name="btnCancel" Content="cancel" Click="btnCancel_Click" Margin="285,218,95,63"/>
10     Grid>
11 Window>

查看代码

背景代码:

 1 using System;
 2 using System.Collections.Generic;
 3 using System.ComponentModel;
 4 using System.Linq;
 5 using System.Text;
 6 using System.Threading;
 7 using System.Windows;
 8 using System.Windows.Controls;
 9 using System.Windows.Data;
10 using System.Windows.Documents;
11 using System.Windows.Input;
12 using System.Windows.Media;
13 using System.Windows.Media.Imaging;
14 using System.Windows.Navigation;
15 using System.Windows.Shapes;
16 
17 namespace BackgroundWorkerDemo20170324
18 {
19     /// 

20     /// Interaction logic for MainWindow.xaml
21     /// 
22     public partial class MainWindow : Window
23     {
24         private BackgroundWorker worker;
25         public MainWindow()
26         {
27             InitializeComponent();
28             worker = new BackgroundWorker();                      //新建BackgroundWorker
29             worker.WorkerReportsProgress = true;                  //允许报告进度
30             worker.WorkerSupportsCancellation = true;             //允许取消线程
31             worker.DoWork += worker_DoWork;                       //设置主要工作逻辑
32             worker.ProgressChanged += worker_ProgressChanged;     //进度变化的相关处理
33             worker.RunWorkerCompleted += worker_RunWorkerCompleted;  //线程完成时的处理
34         }
35 
36         /// 

37         /// 主要工作逻辑
38         /// 
39         /// 
40         /// 
41         private void worker_DoWork(object sender, DoWorkEventArgs e)
42         {
43             BackgroundWorker tempWorker = sender as BackgroundWorker;
44             for (int i = 0; i <= 100; i++)
45             {
46                 Thread.Sleep(200);    //避免太快，让线程暂停一会再报告进度
47                 tempWorker.ReportProgress(i);   //调用ReportProgress()方法报告进度，同时触发ProgressChanged事件
48             }
49         }
50 
51         /// 

52         /// 处理进度变化，改变进度条的值
53         /// 
54         /// 
55         /// 
56         private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
57         {
58             pBar.Value = e.ProgressPercentage;
59         }
60 
61         /// 

62         /// 线程完成后的处理
63         /// 
64         /// 
65         /// 
66         private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
67         {
68             MessageBox.Show("线程工作完成");
69         }
70 
71         /// 

72         /// 点击Start按钮启动线程
73         /// 
74         /// 
75         /// 
76         private void btnStart_Click(object sender, RoutedEventArgs e)
77         {
78             worker.RunWorkerAsync();   //调用该方法才会启动线程
79         }
80 
81         /// 

82         /// 点击Cancel按钮取消线程，但先判断线程是否正在工作
83         /// 
84         /// 
85         /// 
86         private void btnCancel_Click(object sender, RoutedEventArgs e)
87         {
88             if (worker.IsBusy)
89                 worker.CancelAsync();
90             else
91                 MessageBox.Show("There is no thead running now.");
92         }
93     }
94 }

查看代码

2.2.2. 线程可以取消

通常在循环体内（由于循环通常需要更多时间），在需要取消线程的位置判断CancellationPending属性，判断何时CancellationPending == true，

您需要将DoWorkEventArgs的Cancel属性设置为true，然后才能在RunWorkerCompleted中判断RunWorkerCompletedEventArgs的已取消

相应处理的属性（即，当用户取消线程时，还将触发RunWorkerCompleted事件）

修改后的代码:

  1 using System;
  2 using System.Collections.Generic;
  3 using System.ComponentModel;
  4 using System.Linq;
  5 using System.Text;
  6 using System.Threading;
  7 using System.Windows;
  8 using System.Windows.Controls;
  9 using System.Windows.Data;
 10 using System.Windows.Documents;
 11 using System.Windows.Input;
 12 using System.Windows.Media;
 13 using System.Windows.Media.Imaging;
 14 using System.Windows.Navigation;
 15 using System.Windows.Shapes;
 16 
 17 namespace BackgroundWorkerDemo20170324
 18 {
 19     /// 

 20     /// Interaction logic for MainWindow.xaml
 21     /// 
 22     public partial class MainWindow : Window
 23     {
 24         private BackgroundWorker worker;
 25         public MainWindow()
 26         {
 27             InitializeComponent();
 28             worker = new BackgroundWorker();                      //新建BackgroundWorker
 29             worker.WorkerReportsProgress = true;                  //允许报告进度
 30             worker.WorkerSupportsCancellation = true;             //允许取消线程
 31             worker.DoWork += worker_DoWork;                       //设置主要工作逻辑
 32             worker.ProgressChanged += worker_ProgressChanged;     //进度变化的相关处理
 33             worker.RunWorkerCompleted += worker_RunWorkerCompleted;  //线程完成时的处理
 34         }
 35 
 36         /// 

 37         /// 主要工作逻辑
 38         /// 
 39         /// 
 40         /// 
 41         private void worker_DoWork(object sender, DoWorkEventArgs e)
 42         {
 43             BackgroundWorker tempWorker = sender as BackgroundWorker;
 44             for (int i = 0; i <= 100; i++)
 45             {
 46                 if (tempWorker.CancellationPending)  //当点击Cancel按钮时，CancellationPending被设置为true
 47                 {
 48                     e.Cancel = true;  //此处设置Cancel=true后，就可以在RunWorkerCompleted中判断e.Cancelled是否为true
 49                     break;
 50                 }
 51                 Thread.Sleep(200);    //避免太快，让线程暂停一会再报告进度
 52                 tempWorker.ReportProgress(i);   //调用ReportProgress()方法报告进度，同时触发ProgressChanged事件
 53             }
 54         }
 55 
 56         /// 

 57         /// 处理进度变化，改变进度条的值
 58         /// 
 59         /// 
 60         /// 
 61         private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
 62         {
 63             pBar.Value = e.ProgressPercentage;
 64         }
 65 
 66         /// 

 67         /// 线程完成后的处理
 68         /// 
 69         /// 
 70         /// 
 71         private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
 72         {
 73             if (e.Cancelled)  //被取消时
 74                 MessageBox.Show("线程被取消了");
 75             else              //正常结束   
 76                 MessageBox.Show("线程工作完成");
 77         }
 78 
 79         /// 

 80         /// 点击Start按钮启动线程
 81         /// 
 82         /// 
 83         /// 
 84         private void btnStart_Click(object sender, RoutedEventArgs e)
 85         {
 86             worker.RunWorkerAsync();   //调用该方法才会启动线程
 87         }
 88 
 89         /// 

 90         /// 点击Cancel按钮取消线程，但先判断线程是否正在工作
 91         /// 
 92         /// 
 93         /// 
 94         private void btnCancel_Click(object sender, RoutedEventArgs e)
 95         {
 96             if (worker.IsBusy)
 97                 worker.CancelAsync();
 98             else
 99                 MessageBox.Show("There is no thead running now.");
100         }
101     }
102 }

查看代码

3. 程中传递值3.1. 与BackgroundWorker相关的三个参数类

    //
        // 摘要: 
        //     引发 System.ComponentModel.BackgroundWorker.DoWork 事件。
        //
        // 参数: 
        //   e:
        //     包含事件数据的 System.EventArgs。
        protected virtual void OnDoWork(DoWorkEventArgs e);
        //
        // 摘要: 
        //     引发 System.ComponentModel.BackgroundWorker.ProgressChanged 事件。
        //
        // 参数: 
        //   e:
        //     包含事件数据的 System.EventArgs。
        protected virtual void OnProgressChanged(ProgressChangedEventArgs e);
        //
        // 摘要: 
        //     引发 System.ComponentModel.BackgroundWorker.RunWorkerCompleted 事件。
        //
        // 参数: 
        //   e:
        //     包含事件数据的 System.EventArgs。
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e);

通过上面的代码，我们可以看到BackgroundWorker的三个常见事件具有相应的参数类:

3.1.1. DoWorkEventArgs为DoWork事件提供数据backgroundworker 线程操作无效，详细代码如下:

 1 #region 程序集 System.dll, v2.0.0.0
 2 // C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll
 3 #endregion
 4 
 5 using System;
 6 
 7 namespace System.ComponentModel
 8 {
 9     // 摘要: 
10     //     为 System.ComponentModel.BackgroundWorker.DoWork 事件处理程序提供数据。
11     public class DoWorkEventArgs : CancelEventArgs
12     {
13         // 摘要: 
14         //     初始化 System.ComponentModel.DoWorkEventArgs 类的新实例。
15         //
16         // 参数: 
17         //   argument:
18         //     指定异步操作的参数。
19         public DoWorkEventArgs(object argument);
20 
21         // 摘要: 
22         //     获取表示异步操作参数的值。
23         //
24         // 返回结果: 
25         //     表示异步操作参数的 System.Object。
26         public object Argument { get; }
27         //
28         // 摘要: 
29         //     获取或设置表示异步操作结果的值。
30         //
31         // 返回结果: 
32         //     表示异步操作结果的 System.Object。
33         public object Result { get; set; }
34     }
35 }

查看代码

只有两个对象类型属性Argument（只读）和Result，

由于调用RunWorkerAsync（）方法，将触发DoWork事件. 如果小心，您会发现RunWorkerAsync（）方法有两个重载，

带有参数的RunWorkerAsync（对象参数），此参数参数传递给DoWorkEventArgs的Arument属性

Result属性作为DoWork事件的结果传递给RunWorkerCompletedEventArgs的Result属性，

3.1.2. ProgressChangedEventArgs为ProgressChanged事件提供数据，详细代码如下:

 1 using System;
 2 
 3 namespace System.ComponentModel
 4 {
 5     // 摘要: 
 6     //     为 System.ComponentModel.BackgroundWorker.ProgressChanged 事件提供数据。
 7     public class ProgressChangedEventArgs : EventArgs
 8     {
 9         // 摘要: 
10         //     初始化 System.ComponentModel.ProgressChangedEventArgs 类的新实例。
11         //
12         // 参数: 
13         //   progressPercentage:
14         //     已完成的异步任务的百分比。
15         //
16         //   userState:
17         //     唯一的用户状态。
18         public ProgressChangedEventArgs(int progressPercentage, object userState);
19 
20         // 摘要: 
21         //     获取异步任务的进度百分比。
22         //
23         // 返回结果: 
24         //     指示异步任务进度的百分比值。
25         public int ProgressPercentage { get; }
26         //
27         // 摘要: 
28         //     获取唯一的用户状态。
29         //
30         // 返回结果: 
31         //     指示用户状态的唯一 System.Object。
32         public object UserState { get; }
33     }
34 }

查看代码

只有两个属性，它们都是只读的，一个是inger类型的ProgerssPercentage，这意味着任务进度为100％；另一个是对象类型的UserState

这两个参数通过ReportProgress（）方法传入. 由于UserState属性属于对象类型，因此可以在需要实现复制逻辑时自定义类型.

3.1.3. RunWorkerCompletedEventArgs有点特殊，尽管此类的直接定义中只有两个属性，

对象类型Result和UserState的两个只读属性

 1 namespace System.ComponentModel
 2 {
 3     public class RunWorkerCompletedEventArgs : AsyncCompletedEventArgs
 4     {
 5         public RunWorkerCompletedEventArgs(object result, Exception error, bool cancelled);
 6 
 7         public object Result { get; }
 8         [Browsable(false)]
 9         [EditorBrowsable(EditorBrowsableState.Never)]
10         public object UserState { get; }
11     }
12 }

查看代码

但是从父类继承的Canceled和Error属性是关键点.

 1 namespace System.ComponentModel
 2 {
 3     public class AsyncCompletedEventArgs : EventArgs
 4     {
 5         public AsyncCompletedEventArgs(Exception error, bool cancelled, object userState);
 6 
 7         [SRDescription("Async_AsyncEventArgs_Cancelled")]
 8         public bool Cancelled { get; }
 9         [SRDescription("Async_AsyncEventArgs_Error")]
10         public Exception Error { get; }
11         [SRDescription("Async_AsyncEventArgs_UserState")]
12         public object UserState { get; }
13 
14         protected void RaiseExceptionIfNecessary();
15     }
16 }

查看代码

因此，RunWorkerCompletedEventArgs参数主要涉及三个属性: 错误，已取消和结果（通常很少使用UserState）

注意: 标准RunWorkerCompleted处理应首先处理“错误”和“已取消”条件，否则直接访问Result时将报告错误，

尝试以这种方式组织代码逻辑:

 1 // This event handler deals with the results of the
 2 // background operation.
 3 private void backgroundWorker1_RunWorkerCompleted(
 4     object sender, RunWorkerCompletedEventArgs e)
 5 {
 6     // First, handle the case where an exception was thrown.
 7     if (e.Error != null)
 8     {
 9         MessageBox.Show(e.Error.Message);
10     }
11     else if (e.Cancelled)
12     {
13         // Next, handle the case where the user canceled 
14         // the operation.
15         // Note that due to a race condition in 
16         // the DoWork event handler, the Cancelled
17         // flag may not have been set, even though
18         // CancelAsync was called.
19         resultLabel.Text = "Canceled";
20     }
21     else
22     {
23         // Finally, handle the case where the operation 
24         // succeeded.
25         resultLabel.Text = e.Result.ToString();
26     }
27 }

查看代码

4. 注意事项4.1. DoWork事件期间无法与UI控件通信

如果您需要程处理过程中与UI控件进行通信，请在ProgressChanged和RunWorkerCompleted中进行操作，否则会发生以下错误

System.InvalidOperationException was unhandled by user code
  Message=The calling thread cannot access this object because a different thread owns it.
  Source=WindowsBase
  StackTrace:
       at System.Windows.Threading.Dispatcher.VerifyAccess()
       at System.Windows.DependencyObject.SetValue(DependencyProperty dp, Object value)
       at System.Windows.Controls.Primitives.RangeBase.set_Value(Double value)
       at BackgroundWorkerDemo20170324.MainWindow.worker_DoWork(Object sender, DoWorkEventArgs e) in 

5. 与5.1. Visual Studio中的API如下所示:

代码:

 1 using System;
 2 
 3 namespace System.ComponentModel
 4 {
 5     [DefaultEvent("DoWork")]
 6     public class BackgroundWorker : Component
 7     {
 8         public BackgroundWorker();
 9 
10         [Browsable(false)]
11         public bool CancellationPending { get; }                          //用于判断是否取消了线程
12         [Browsable(false)]
13         public bool IsBusy { get; }                                       //判断当前线程是否正在工作
14         [DefaultValue(false)]
15         public bool WorkerReportsProgress { get; set; }                   //是否报告进度
16         [DefaultValue(false)]
17         public bool WorkerSupportsCancellation { get; set; }              //是否支持取消线程，如果要调用CancelAsyns()方法，必须设置为true
18 
19         public event DoWorkEventHandler DoWork;                           //线程核心代码，耗时的操作放在这里，调用RunWorkerAsync()时触发            
20         public event ProgressChangedEventHandler ProgressChanged;         //当进度改变后执行的代码，调用ReportProgress()时触发
21         public event RunWorkerCompletedEventHandler RunWorkerCompleted;   //3种情况：当线程完成、手动取消线程时、线程发生异常时触发
22 
23         public void CancelAsync();                                        //调用该方法会发出取消线程的消息，但并不会立即中止线程
24         protected virtual void OnDoWork(DoWorkEventArgs e);
25         protected virtual void OnProgressChanged(ProgressChangedEventArgs e);
26         protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e);
27         public void ReportProgress(int percentProgress);                  //调用该方法就触发ProgressChanged事件，相当于ReportProgress(int percentProgress, null)
28         public void ReportProgress(int percentProgress, object userState); 
29         public void RunWorkerAsync();                                     //调用该方法启动线程，同时触发DoWork事件，相当于RunWorkerAsync(null)
30         public void RunWorkerAsync(object argument);
31     }
32 }

查看代码

5.2. 相关的博客建议，非常好，值得一看:

[您必须知道的异步编程]-基于事件的异步编程模式；

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-289312-1.html