C#多线程BackgroundWorker使用示例

using System;

using System.Collections.Generic;

using System.ComponentModel;////

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Windows.Forms;

using System.Threading;

namespace BackgroundWorkerSample

{

    public partial class CalculateAddForm : Form

    {

        protected BackgroundWorker backgroundWorker1 = new BackgroundWorker();

        //private int numberToCompute = 0;

        //private int highestPercentageReached = 0;

        public CalculateAddForm()

        {

            InitializeComponent();

            InitializeBackgoundWorker();

        }

        // Set up the BackgroundWorker object by

        // attaching event handlers.

        private void InitializeBackgoundWorker()

            this.backgroundWorker1.WorkerReportsProgress = true;

            this.backgroundWorker1.WorkerSupportsCancellation = true;

            this.backgroundWorker1.DoWork += new DoWorkEventHandler(backgroundWorker1_DoWork);

            this.backgroundWorker1.ProgressChanged += new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged);

            this.backgroundWorker1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(backgroundWorker1_RunWorkerCompleted);

        private long ComputeAdd(int n, BackgroundWorker worker, DoWorkEventArgs e)

            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.

            for (int i = 1; i <= n; i++)

            {

                if (worker.CancellationPending)

                {

                    e.Cancel = true;

                    break;

                }

                else

                    result += i;

                    Thread.Sleep(100);

                    // Report progress as a percentage of the total task.

                    int percentComplete = (int)((float)i / (float)n * 100);

                    worker.ReportProgress(percentComplete);

            }

            return result;

        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 = ComputeAdd((int)e.Argument, worker, e);

            // If the operation was canceled by the user,

            // set the DoWorkEventArgs.Cancel property to true.

            if (worker.CancellationPending)

                e.Cancel = true;

        void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)

            this.progressBar1.Value = e.ProgressPercentage;

        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;

        private void startAsyncButton_Click(object sender, 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

            this.startAsyncButton.Enabled = false;

            // Enable the Cancel button while

            // the asynchronous operation runs.

            this.cancelAsyncButton.Enabled = true;

            // Get the value from the UpDown control.

            int numberToCompute = (int)numericUpDown1.Value;

            // Reset the variable for percentage tracking.

            //highestPercentageReached = 0;

            // Start the asynchronous operation.

            backgroundWorker1.RunWorkerAsync(numberToCompute);

        private void cancelAsyncButton_Click(object sender, EventArgs e)

            // Cancel the asynchronous operation.

            this.backgroundWorker1.CancelAsync();

        }       

    }

}