本文為機器翻譯文章。如需檢視英文版,請選取 [原文] 核取方塊。您也可以將滑鼠指標移到文字上,即可在快顯視窗顯示英文原文。
譯文
原文

BackgroundWorker 類別

 

在不同執行緒上執行作業。

命名空間:   System.ComponentModel
組件:  System (於 System.dll)

System.Object
  System.MarshalByRefObject
    System.ComponentModel.Component
      System.ComponentModel.BackgroundWorker

[HostProtectionAttribute(SecurityAction.LinkDemand, SharedState = true)]
public class BackgroundWorker : Component

名稱描述
System_CAPS_pubmethodBackgroundWorker()

初始化 BackgroundWorker 類別的新執行個體。

名稱描述
System_CAPS_pubpropertyCancellationPending

取得值,指出應用程式是否已要求取消背景作業。

System_CAPS_protpropertyCanRaiseEvents

取得值,指出元件是否可以引發事件。(繼承自 Component。)

System_CAPS_pubpropertyContainer

取得 IContainer ,其中包含 Component(繼承自 Component。)

System_CAPS_protpropertyDesignMode

取得值,指出是否 Component 目前正處於設計模式。(繼承自 Component。)

System_CAPS_protpropertyEvents

取得事件處理常式附加至這個清單 Component(繼承自 Component。)

System_CAPS_pubpropertyIsBusy

取得值,指出是否 BackgroundWorker 執行非同步作業。

System_CAPS_pubpropertySite

取得或設定 ISiteComponent(繼承自 Component。)

System_CAPS_pubpropertyWorkerReportsProgress

取得或設定值,指出是否 BackgroundWorker 可以報告進度更新。

System_CAPS_pubpropertyWorkerSupportsCancellation

取得或設定值,指出是否 BackgroundWorker 支援非同步取消作業。

名稱描述
System_CAPS_pubmethodCancelAsync()

要求取消暫止的背景作業。

System_CAPS_pubmethodCreateObjRef(Type)

建立物件,包含要產生 proxy 用來與遠端物件通訊所需的所有相關資訊。(繼承自 MarshalByRefObject。)

System_CAPS_pubmethodDispose()

釋放 Component 所使用的所有資源。(繼承自 Component。)

System_CAPS_protmethodDispose(Boolean)

釋放 Component 所使用的 Unmanaged 資源,並選擇性地釋放 Managed 資源。(繼承自 Component。)

System_CAPS_pubmethodEquals(Object)

判斷指定的物件是否等於目前的物件。(繼承自 Object。)

System_CAPS_protmethodFinalize()

釋出 Unmanaged 資源並執行其他清除作業後,記憶體回收才能重新回收 Component(繼承自 Component。)

System_CAPS_pubmethodGetHashCode()

做為預設雜湊函式。(繼承自 Object。)

System_CAPS_pubmethodGetLifetimeService()

擷取目前存留期間的服務物件可控制這個執行個體的存留期原則。(繼承自 MarshalByRefObject。)

System_CAPS_protmethodGetService(Type)

傳回表示 Component 或其 Container 所提供之服務的物件。(繼承自 Component。)

System_CAPS_pubmethodGetType()

取得目前執行個體的 Type(繼承自 Object。)

System_CAPS_pubmethodInitializeLifetimeService()

取得存留期服務物件,以控制這個執行個體的存留期原則。(繼承自 MarshalByRefObject。)

System_CAPS_protmethodMemberwiseClone()

建立目前 Object 的淺層複製。(繼承自 Object。)

System_CAPS_protmethodMemberwiseClone(Boolean)

建立目前的淺層複本MarshalByRefObject物件。(繼承自 MarshalByRefObject。)

System_CAPS_protmethodOnDoWork(DoWorkEventArgs)

引發 DoWork 事件。

System_CAPS_protmethodOnProgressChanged(ProgressChangedEventArgs)

引發 ProgressChanged 事件。

System_CAPS_protmethodOnRunWorkerCompleted(RunWorkerCompletedEventArgs)

引發 RunWorkerCompleted 事件。

System_CAPS_pubmethodReportProgress(Int32)

引發 ProgressChanged 事件。

System_CAPS_pubmethodReportProgress(Int32, Object)

引發 ProgressChanged 事件。

System_CAPS_pubmethodRunWorkerAsync()

開始執行背景作業。

System_CAPS_pubmethodRunWorkerAsync(Object)

開始執行背景作業。

System_CAPS_pubmethodToString()

傳回 String 包含名稱的 Component, ,若有的話。 不應覆寫此方法。(繼承自 Component。)

名稱描述
System_CAPS_pubeventDisposed

藉由呼叫處置元件時,會發生 Dispose 方法。(繼承自 Component。)

System_CAPS_pubeventDoWork

發生於當 RunWorkerAsync 呼叫。

System_CAPS_pubeventProgressChanged

發生於當 ReportProgress 呼叫。

System_CAPS_pubeventRunWorkerCompleted

發生於背景作業已完成、 已取消,或引發例外狀況。

The T:System.ComponentModel.BackgroundWorker class allows you to run an operation on a separate, dedicated thread. Time-consuming operations like downloads and database transactions can cause your user interface (UI) to seem as though it has stopped responding while they are running. When you want a responsive UI and you are faced with long delays associated with such operations, the T:System.ComponentModel.BackgroundWorker class provides a convenient solution.

To execute a time-consuming operation in the background, create a T:System.ComponentModel.BackgroundWorker and listen for events that report the progress of your operation and signal when your operation is finished. You can create the T:System.ComponentModel.BackgroundWorker programmatically or you can drag it onto your form from the Components tab of the Toolbox. If you create the T:System.ComponentModel.BackgroundWorker in the Windows Forms Designer, it will appear in the Component Tray, and its properties will be displayed in the Properties window.

To set up for a background operation, add an event handler for the E:System.ComponentModel.BackgroundWorker.DoWork event. Call your time-consuming operation in this event handler. To start the operation, call M:System.ComponentModel.BackgroundWorker.RunWorkerAsync. To receive notifications of progress updates, handle the E:System.ComponentModel.BackgroundWorker.ProgressChanged event. To receive a notification when the operation is completed, handle the E:System.ComponentModel.BackgroundWorker.RunWorkerCompleted event.

System_CAPS_note注意

You must be careful not to manipulate any user-interface objects in your E:System.ComponentModel.BackgroundWorker.DoWork event handler. Instead, communicate to the user interface through the E:System.ComponentModel.BackgroundWorker.ProgressChanged and E:System.ComponentModel.BackgroundWorker.RunWorkerCompleted events.

BackgroundWorker events are not marshaled across AppDomain boundaries. Do not use a BackgroundWorker component to perform multithreaded operations in more than one AppDomain.

If your background operation requires a parameter, call M:System.ComponentModel.BackgroundWorker.RunWorkerAsync with your parameter. Inside the E:System.ComponentModel.BackgroundWorker.DoWork event handler, you can extract the parameter from the P:System.ComponentModel.DoWorkEventArgs.Argument property.

For more information about T:System.ComponentModel.BackgroundWorker, see How to: Run an Operation in the Background.

The following code example demonstrates the basics of the T:System.ComponentModel.BackgroundWorker class for executing a time-consuming operation asynchronously. The following illustration shows an example of the output.

BackgroundWorker 簡單範例

To try this code, create a Windows Forms application. Add a T:System.Windows.Forms.Label control named resultLabel and add two T:System.Windows.Forms.Button controls named startAsyncButton and cancelAsyncButton. Create E:System.Windows.Forms.Control.Click event handlers for both buttons. From the Components tab of the Toolbox, add a T:System.ComponentModel.BackgroundWorker component named backgroundWorker1. Create E:System.ComponentModel.BackgroundWorker.DoWork, E:System.ComponentModel.BackgroundWorker.ProgressChanged, and E:System.ComponentModel.BackgroundWorker.RunWorkerCompleted event handlers for the T:System.ComponentModel.BackgroundWorker. In the code for the form, replace the existing code with the following code.

using System;
using System.ComponentModel;
using System.Windows.Forms;

namespace BackgroundWorkerSimple
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            backgroundWorker1.WorkerReportsProgress = true;
            backgroundWorker1.WorkerSupportsCancellation = true;
        }

        private void startAsyncButton_Click(object sender, EventArgs e)
        {
            if (backgroundWorker1.IsBusy != true)
            {
                // Start the asynchronous operation.
                backgroundWorker1.RunWorkerAsync();
            }
        }

        private void cancelAsyncButton_Click(object sender, EventArgs e)
        {
            if (backgroundWorker1.WorkerSupportsCancellation == true)
            {
                // Cancel the asynchronous operation.
                backgroundWorker1.CancelAsync();
            }
        }

        // This event handler is where the time-consuming work is done.
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker worker = sender as BackgroundWorker;

            for (int i = 1; i <= 10; i++)
            {
                if (worker.CancellationPending == true)
                {
                    e.Cancel = true;
                    break;
                }
                else
                {
                    // Perform a time consuming operation and report progress.
                    System.Threading.Thread.Sleep(500);
                    worker.ReportProgress(i * 10);
                }
            }
        }

        // This event handler updates the progress.
        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            resultLabel.Text = (e.ProgressPercentage.ToString() + "%");
        }

        // This event handler deals with the results of the background operation.
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled == true)
            {
                resultLabel.Text = "Canceled!";
            }
            else if (e.Error != null)
            {
                resultLabel.Text = "Error: " + e.Error.Message;
            }
            else
            {
                resultLabel.Text = "Done!";
            }
        }
    }
}

The following code example demonstrates the use of the T:System.ComponentModel.BackgroundWorker class for executing a time-consuming operation asynchronously. The following illustration shows an example of the output.

BackgroundWorker Fibonacci 範例

The operation computes the selected Fibonacci number, reports progress updates as the calculation proceeds, and permits a pending calculation to be canceled.

using System;
using System.Collections;
using System.ComponentModel;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;

namespace BackgroundWorkerExample
{	
    public class FibonacciForm : System.Windows.Forms.Form
    {	
        private int numberToCompute = 0;
        private int highestPercentageReached = 0;

        private System.Windows.Forms.NumericUpDown numericUpDown1;
        private System.Windows.Forms.Button startAsyncButton;
        private System.Windows.Forms.Button cancelAsyncButton;
        private System.Windows.Forms.ProgressBar progressBar1;
        private System.Windows.Forms.Label resultLabel;
        private System.ComponentModel.BackgroundWorker backgroundWorker1;

        public FibonacciForm()
        {	
            InitializeComponent();

            InitializeBackgroundWorker();
        }

        // Set up the BackgroundWorker object by 
        // attaching event handlers. 
        private void InitializeBackgroundWorker()
        {
            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;
        }


		#region Windows Form Designer generated code

        private void InitializeComponent()
        {
            this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
            this.startAsyncButton = new System.Windows.Forms.Button();
            this.cancelAsyncButton = new System.Windows.Forms.Button();
            this.resultLabel = new System.Windows.Forms.Label();
            this.progressBar1 = new System.Windows.Forms.ProgressBar();
            this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
            this.SuspendLayout();
            // 
            // numericUpDown1
            // 
            this.numericUpDown1.Location = new System.Drawing.Point(16, 16);
            this.numericUpDown1.Maximum = new System.Decimal(new int[] {
            91,
            0,
            0,
            0});
            this.numericUpDown1.Minimum = new System.Decimal(new int[] {
            1,
            0,
            0,
            0});
            this.numericUpDown1.Name = "numericUpDown1";
            this.numericUpDown1.Size = new System.Drawing.Size(80, 20);
            this.numericUpDown1.TabIndex = 0;
            this.numericUpDown1.Value = new System.Decimal(new int[] {
            1,
            0,
            0,
            0});
            // 
            // startAsyncButton
            // 
            this.startAsyncButton.Location = new System.Drawing.Point(16, 72);
            this.startAsyncButton.Name = "startAsyncButton";
            this.startAsyncButton.Size = new System.Drawing.Size(120, 23);
            this.startAsyncButton.TabIndex = 1;
            this.startAsyncButton.Text = "Start Async";
            this.startAsyncButton.Click += new System.EventHandler(this.startAsyncButton_Click);
            // 
            // cancelAsyncButton
            // 
            this.cancelAsyncButton.Enabled = false;
            this.cancelAsyncButton.Location = new System.Drawing.Point(153, 72);
            this.cancelAsyncButton.Name = "cancelAsyncButton";
            this.cancelAsyncButton.Size = new System.Drawing.Size(119, 23);
            this.cancelAsyncButton.TabIndex = 2;
            this.cancelAsyncButton.Text = "Cancel Async";
            this.cancelAsyncButton.Click += new System.EventHandler(this.cancelAsyncButton_Click);
            // 
            // resultLabel
            // 
            this.resultLabel.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
            this.resultLabel.Location = new System.Drawing.Point(112, 16);
            this.resultLabel.Name = "resultLabel";
            this.resultLabel.Size = new System.Drawing.Size(160, 23);
            this.resultLabel.TabIndex = 3;
            this.resultLabel.Text = "(no result)";
            this.resultLabel.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
            // 
            // progressBar1
            // 
            this.progressBar1.Location = new System.Drawing.Point(18, 48);
            this.progressBar1.Name = "progressBar1";
            this.progressBar1.Size = new System.Drawing.Size(256, 8);
            this.progressBar1.Step = 2;
            this.progressBar1.TabIndex = 4;
            // 
            // backgroundWorker1
            // 
            this.backgroundWorker1.WorkerReportsProgress = true;
            this.backgroundWorker1.WorkerSupportsCancellation = true;
            // 
            // FibonacciForm
            // 
            this.ClientSize = new System.Drawing.Size(292, 118);
            this.Controls.Add(this.progressBar1);
            this.Controls.Add(this.resultLabel);
            this.Controls.Add(this.cancelAsyncButton);
            this.Controls.Add(this.startAsyncButton);
            this.Controls.Add(this.numericUpDown1);
            this.Name = "FibonacciForm";
            this.Text = "Fibonacci Calculator";
            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
            this.ResumeLayout(false);

        }
		#endregion

        [STAThread]
        static void Main()
        {
            Application.Run(new FibonacciForm());
        }
    }
}

通用 Windows 平台
自 10 起供應
.NET Framework
自 2.0 起供應
Silverlight
自 2.0 起供應
Windows Phone Silverlight
自 7.0 起供應

此類型的任何 public static (在 Visual Basic 中 共用 在 Visual Basic 中) 成員皆為安全執行緒。不保證任何執行個體成員為安全執行緒。

回到頁首
顯示: