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. 三個常用事件：

　　　　public event DoWorkEventHandler DoWork; //開始 必須，線程的主要邏輯，調用RunWorkerAsync()時觸發該事件

　　　　public event ProgressChangedEventHandler ProgressChanged; //報告 可選，報告進度事件，調用ReportProgress()時觸發該事件

　　　　public event RunWorkerCompletedEventHandler RunWorkerCompleted; //結束 可選，當線程運行完畢、發生異常和調用CancelAsync()方法這三種方式都會觸發該事件

      1.3. 三個常用方法：

　　　　public void RunWorkerAsync(); //啟動線程，觸發DoWork事件
　　　　public void RunWorkerAsync(object argument);

　　　　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個Button

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

                 后台代碼：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace BackgroundWorkerDemo20170324
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private BackgroundWorker worker;
        public MainWindow()
        {
            InitializeComponent();
            worker = new BackgroundWorker();                      //新建BackgroundWorker
            worker.WorkerReportsProgress = true;                  //允許報告進度
            worker.WorkerSupportsCancellation = true;             //允許取消線程
            worker.DoWork += worker_DoWork;                       //設置主要工作邏輯
            worker.ProgressChanged += worker_ProgressChanged;     //進度變化的相關處理
            worker.RunWorkerCompleted += worker_RunWorkerCompleted;  //線程完成時的處理
        }

        /// <summary>
        /// 主要工作邏輯
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker tempWorker = sender as BackgroundWorker;
            for (int i = 0; i <= 100; i++)
            {
                Thread.Sleep(200);    //避免太快，讓線程暫停一會再報告進度
                tempWorker.ReportProgress(i);   //調用ReportProgress()方法報告進度，同時觸發ProgressChanged事件
            }
        }

        /// <summary>
        /// 處理進度變化，改變進度條的值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            pBar.Value = e.ProgressPercentage;
        }

        /// <summary>
        /// 線程完成后的處理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            MessageBox.Show("線程工作完成");
        }

        /// <summary>
        /// 點擊Start按鈕啟動線程
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            worker.RunWorkerAsync();   //調用該方法才會啟動線程
        }

        /// <summary>
        /// 點擊Cancel按鈕取消線程，但先判斷線程是否正在工作
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, RoutedEventArgs e)
        {
            if (worker.IsBusy)
                worker.CancelAsync();
            else
                MessageBox.Show("There is no thead running now.");
        }
    }
}

         2.2.2. 能取消線程

               在需要取消線程的位置判斷CancellationPending屬性，一般在循環體中（因為循環一般耗時居多），判斷當CancellationPending==true時，

　　需要將DoWorkEventArgs的Cancel屬性設置為true, 然后就可以在RunWorkerCompleted中判斷RunWorkerCompletedEventArgs的Cancelled

　　屬性來進行對應的處理（即，當用戶取消線程時，也會觸發RunWorkerCompleted事件）

          修改后的代碼：

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace BackgroundWorkerDemo20170324
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        private BackgroundWorker worker;
        public MainWindow()
        {
            InitializeComponent();
            worker = new BackgroundWorker();                      //新建BackgroundWorker
            worker.WorkerReportsProgress = true;                  //允許報告進度
            worker.WorkerSupportsCancellation = true;             //允許取消線程
            worker.DoWork += worker_DoWork;                       //設置主要工作邏輯
            worker.ProgressChanged += worker_ProgressChanged;     //進度變化的相關處理
            worker.RunWorkerCompleted += worker_RunWorkerCompleted;  //線程完成時的處理
        }

        /// <summary>
        /// 主要工作邏輯
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker tempWorker = sender as BackgroundWorker;
            for (int i = 0; i <= 100; i++)
            {
                if (tempWorker.CancellationPending)  //當點擊Cancel按鈕時，CancellationPending被設置為true
                {
                    e.Cancel = true;  //此處設置Cancel=true后，就可以在RunWorkerCompleted中判斷e.Cancelled是否為true
                    break;
                }
                Thread.Sleep(200);    //避免太快，讓線程暫停一會再報告進度
                tempWorker.ReportProgress(i);   //調用ReportProgress()方法報告進度，同時觸發ProgressChanged事件
            }
        }

        /// <summary>
        /// 處理進度變化，改變進度條的值
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            pBar.Value = e.ProgressPercentage;
        }

        /// <summary>
        /// 線程完成后的處理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)  //被取消時
                MessageBox.Show("線程被取消了");
            else              //正常結束   
                MessageBox.Show("線程工作完成");
        }

        /// <summary>
        /// 點擊Start按鈕啟動線程
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnStart_Click(object sender, RoutedEventArgs e)
        {
            worker.RunWorkerAsync();   //調用該方法才會啟動線程
        }

        /// <summary>
        /// 點擊Cancel按鈕取消線程，但先判斷線程是否正在工作
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnCancel_Click(object sender, RoutedEventArgs e)
        {
            if (worker.IsBusy)
                worker.CancelAsync();
            else
                MessageBox.Show("There is no thead running now.");
        }
    }
}

 

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事件提供數據，詳細代碼如下：

#region 程序集 System.dll, v2.0.0.0
// C:\Windows\Microsoft.NET\Framework\v2.0.50727\System.dll
#endregion

using System;

namespace System.ComponentModel
{
    // 摘要: 
    //     為 System.ComponentModel.BackgroundWorker.DoWork 事件處理程序提供數據。
    public class DoWorkEventArgs : CancelEventArgs
    {
        // 摘要: 
        //     初始化 System.ComponentModel.DoWorkEventArgs 類的新實例。
        //
        // 參數: 
        //   argument:
        //     指定異步操作的參數。
        public DoWorkEventArgs(object argument);

        // 摘要: 
        //     獲取表示異步操作參數的值。
        //
        // 返回結果: 
        //     表示異步操作參數的 System.Object。
        public object Argument { get; }
        //
        // 摘要: 
        //     獲取或設置表示異步操作結果的值。
        //
        // 返回結果: 
        //     表示異步操作結果的 System.Object。
        public object Result { get; set; }
    }
}

　　　  只有兩個object類型的屬性Argument(只讀的)和Result，

          因為調用RunWorkerAsync()方法，就會觸發DoWork事件，細心的你會發現，RunWorkerAsync()方法有兩個重載，

          帶有參數的RunWorkerAsync(object argument)，這個形參argument就是傳遞給DoWorkEventArgs的Arument屬性的

          而Result屬性是作為DoWork事件的結果傳遞給RunWorkerCompletedEventArgs的Result屬性，

          

             3.1.2.  ProgressChangedEventArgs 為ProgressChanged事件提供數據，詳細代碼如下：

using System;

namespace System.ComponentModel
{
    // 摘要: 
    //     為 System.ComponentModel.BackgroundWorker.ProgressChanged 事件提供數據。
    public class ProgressChangedEventArgs : EventArgs
    {
        // 摘要: 
        //     初始化 System.ComponentModel.ProgressChangedEventArgs 類的新實例。
        //
        // 參數: 
        //   progressPercentage:
        //     已完成的異步任務的百分比。
        //
        //   userState:
        //     唯一的用戶狀態。
        public ProgressChangedEventArgs(int progressPercentage, object userState);

        // 摘要: 
        //     獲取異步任務的進度百分比。
        //
        // 返回結果: 
        //     指示異步任務進度的百分比值。
        public int ProgressPercentage { get; }
        //
        // 摘要: 
        //     獲取唯一的用戶狀態。
        //
        // 返回結果: 
        //     指示用戶狀態的唯一 System.Object。
        public object UserState { get; }
    }
}

             也只有兩個屬性,都是只讀的，一個為int類型的ProgerssPercentage，表示任務進度百分百；另一個是object類型的UserState

             這兩個參數都是通過ReportProgress()方法傳入，由於UserState屬性時object類型的，所以當需要實現復制邏輯時，可以自定義一個類型

 

             3.1.3. RunWorkerCompletedEventArgs 稍微特殊一點，雖然該類的直接定義中只有兩個屬性，

            object類型的兩個只讀屬性Result和UserState

namespace System.ComponentModel
{
    public class RunWorkerCompletedEventArgs : AsyncCompletedEventArgs
    {
        public RunWorkerCompletedEventArgs(object result, Exception error, bool cancelled);

        public object Result { get; }
        [Browsable(false)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public object UserState { get; }
    }
}

            但從父類繼承過來的Cancelled和Error屬性才是重點

namespace System.ComponentModel
{
    public class AsyncCompletedEventArgs : EventArgs
    {
        public AsyncCompletedEventArgs(Exception error, bool cancelled, object userState);

        [SRDescription("Async_AsyncEventArgs_Cancelled")]
        public bool Cancelled { get; }
        [SRDescription("Async_AsyncEventArgs_Error")]
        public Exception Error { get; }
        [SRDescription("Async_AsyncEventArgs_UserState")]
        public object UserState { get; }

        protected void RaiseExceptionIfNecessary();
    }
}

           所以，RunWorkerCompletedEventArgs參數主要關心三個屬性，Error、Cancelled、Result (UserState一般很少用到)

           注意：標准的RunWorkerCompleted處理都應該先處理Error和Cancelled情況，否則直接訪問Result時會報錯，

       盡量以這種方式來整理自己的代碼邏輯：

// 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();
    }
}

 

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顯示如下：

             代碼：

using System;

namespace System.ComponentModel
{
    [DefaultEvent("DoWork")]
    public class BackgroundWorker : Component
    {
        public BackgroundWorker();

        [Browsable(false)]
        public bool CancellationPending { get; }                          //用於判斷是否取消了線程
        [Browsable(false)]
        public bool IsBusy { get; }                                       //判斷當前線程是否正在工作
        [DefaultValue(false)]
        public bool WorkerReportsProgress { get; set; }                   //是否報告進度
        [DefaultValue(false)]
        public bool WorkerSupportsCancellation { get; set; }              //是否支持取消線程，如果要調用CancelAsyns()方法，必須設置為true

        public event DoWorkEventHandler DoWork;                           //線程核心代碼，耗時的操作放在這里，調用RunWorkerAsync()時觸發            
        public event ProgressChangedEventHandler ProgressChanged;         //當進度改變后執行的代碼，調用ReportProgress()時觸發
        public event RunWorkerCompletedEventHandler RunWorkerCompleted;   //3種情況：當線程完成、手動取消線程時、線程發生異常時觸發

        public void CancelAsync();                                        //調用該方法會發出取消線程的消息，但並不會立即中止線程
        protected virtual void OnDoWork(DoWorkEventArgs e);
        protected virtual void OnProgressChanged(ProgressChangedEventArgs e);
        protected virtual void OnRunWorkerCompleted(RunWorkerCompletedEventArgs e);
        public void ReportProgress(int percentProgress);                  //調用該方法就觸發ProgressChanged事件，相當於ReportProgress(int percentProgress, null)
        public void ReportProgress(int percentProgress, object userState); 
        public void RunWorkerAsync();                                     //調用該方法啟動線程，同時觸發DoWork事件，相當於RunWorkerAsync(null)
        public void RunWorkerAsync(object argument);
    }
}

 

 

 

 

     5.2. 相關博客推薦，非常優秀，值得查看：

               [你必須知道的異步編程]——基於事件的異步編程模式 ;

               http://m.blog.csdn.net/article/details?id=7291070