Este artigo foi traduzido por máquina. Para visualizar o arquivo em inglês, marque a caixa de seleção Inglês. Você também pode exibir o texto Em inglês em uma janela pop-up, movendo o ponteiro do mouse sobre o texto.
Tradução
Inglês

BackgroundWorker Classe

Executa uma operação em uma thread separada.

Namespace:  System.ComponentModel
Assembly:  System (em System. dll)

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

ObservaçãoObservação:

O atributo HostProtectionAttribute aplicado a esse tipo ou membro tem o seguinte Resources valor da propriedade: SharedState. O HostProtectionAttribute não afeta área de trabalho aplicativos (que são geralmente iniciado por duas vezes em um ícone, digitando um comando ou inserindo um URL em um navegador). Para obter mais informações, consulte a classe HostProtectionAttribute ou Programação SQL Servidor e atributos de proteção de host.

A classe BackgroundWorker permite que você execute uma operação em uma thread dedicada separadamente. Operações demoradas, como downloads e transações com o banco de dados, podem fazer com que sua interface de usuário (UI) tenha parado de responder enquanto estão sendo executados. When you want a responsive UI and you are faced with long delays associated with such operations, the BackgroundWorker class provides a convenient solution.

To execute a time-consuming operation in the background, create a BackgroundWorker and listen for events that report the progress of your operation and signal when your operation is finished.Você pode criar o BackgroundWorker programaticamente ou você pode arrastar para seu formulário a partir da guia Componentes da Toolbox.If you create the 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 DoWork event.Chame sua operação demorada neste manipulador de eventos.To start the operation, call RunWorkerAsync.To receive notifications of progress updates, handle the ProgressChanged event.To receive a notification when the operation is completed, handle the RunWorkerCompleted event.

ObservaçãoObservação:

Você deve ter cuidado para não manipular quaisquer objetos de interface do usuário em seu manipulador de eventos DoWork . Em vez disso, se comunique com a interface do usuário por meio dos eventos ProgressChanged e RunWorkerCompleted.

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

Se a operação de plano de fundo exige um parâmetro, chame o método RunWorkerAsync com o parâmetro. Dentro do manipulador de eventos DoWork, você pode extrair o parâmetro da propriedade DoWorkEventArgs.Argument.

Para mais informações sobre o BackgroundWorker, veja Como: Executar uma operação em segundo plano.

The following code example demonstrates the use of the BackgroundWorker class for executing a time-consuming operation asynchronously.The selected número Fibonacci, computes the operação Reports Progresso Updates as proceeds the calculation, and Permits a pendente 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();

            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;
        }


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



import System.* ;
import System.Collections.* ;
import System.ComponentModel.* ;
import System.Drawing.* ;
import System.Threading.* ;
import System.Windows.Forms.* ;

public class FibonacciForm extends 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();
        InitializeBackgoundWorker();
    } //FibonacciForm

    // Set up the BackgroundWorker object by 
    // attaching event handlers. 
    private void InitializeBackgoundWorker()
    {
        backgroundWorker1.add_DoWork(new DoWorkEventHandler(
            backgroundWorker1_DoWork));
        backgroundWorker1.add_RunWorkerCompleted(
            new RunWorkerCompletedEventHandler(
            backgroundWorker1_RunWorkerCompleted));
        backgroundWorker1.add_ProgressChanged(
            new ProgressChangedEventHandler(backgroundWorker1_ProgressChanged));
    } //InitializeBackgoundWorker

    private void startAsyncButton_Click(Object sender, EventArgs e)
    {
        // Reset the text in the result label.
        resultLabel.set_Text(String.Empty);

        // Disable the UpDown control until 
        // the asynchronous operation is done.
        this.numericUpDown1.set_Enabled(false);

        // Disable the Start button until 
        // the asynchronous operation is done.
        this.startAsyncButton.set_Enabled(false);

        // Enable the Cancel button while 
        // the asynchronous operation runs.
        this.cancelAsyncButton.set_Enabled(true);

        // Get the value from the UpDown control.
        numberToCompute = System.Convert.ToInt32((numericUpDown1.get_Value()));

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

        // Start the asynchronous operation.
        backgroundWorker1.RunWorkerAsync(System.Convert.ToString
            (numberToCompute));
    }

    private void cancelAsyncButton_Click(Object sender, System.EventArgs e)
    {   
        // Cancel the asynchronous operation.
        this.backgroundWorker1.CancelAsync();

        // Disable the Cancel button.
        cancelAsyncButton.set_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 = (BackgroundWorker)sender;

        // Assign the result of the computation
        // to the Result property of the DoWorkEventArgs
        // object. This is will be available to the 
        // RunWorkerCompleted eventhandler.
        e.set_Result(new Long(ComputeFibonacci(System.Convert.ToInt32
            (e.get_Argument()), worker, e)));
        //e.Result = ComputeFibonacci((int)e.Argument, worker, e); 
    } //backgroundWorker1_DoWork

    // 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.get_Error() != null) {

            MessageBox.Show(e.get_Error().get_Message());
        }
        else {

            if (e.get_Cancelled()) {

                // Next, handle the case where the user cancelled 
                // 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.set_Text("Cancelled");
            }
            else {

                // Finally, handle the case where the operation 
                // succeeded.
                resultLabel.set_Text(e.get_Result().ToString());
            }
        }

        // Enable the UpDown control.
        this.numericUpDown1.set_Enabled(true);

        // Enable the Start button.
        startAsyncButton.set_Enabled(true);

        // Disable the Cancel button.
        cancelAsyncButton.set_Enabled(false);
    } //backgroundWorker1_RunWorkerCompleted

    // This event handler updates the progress bar.
    private void backgroundWorker1_ProgressChanged(Object sender,
        ProgressChangedEventArgs e)
    {
        this.progressBar1.set_Value(e.get_ProgressPercentage());
    } //backgroundWorker1_ProgressChanged

    // 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 cancelled.
        // 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.get_CancellationPending()) {

            e.set_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.set_Location(new System.Drawing.Point(16, 16));
        this.numericUpDown1.set_Maximum(new System.Decimal(
            new int[] { 91, 0, 0, 0 }));
        this.numericUpDown1.set_Minimum(new System.Decimal(
            new int[] { 1, 0, 0, 0 }));
        this.numericUpDown1.set_Name("numericUpDown1");
        this.numericUpDown1.set_Size(new System.Drawing.Size(80, 20));
        this.numericUpDown1.set_TabIndex(0);
        this.numericUpDown1.set_Value(new System.Decimal(
            new int[] { 1, 0, 0, 0 }));

        // 
        // startAsyncButton
        // 
        this.startAsyncButton.set_Location(new System.Drawing.Point(16, 72));
        this.startAsyncButton.set_Name("startAsyncButton");
        this.startAsyncButton.set_Size(new System.Drawing.Size(120, 23));
        this.startAsyncButton.set_TabIndex(1);
        this.startAsyncButton.set_Text("Start Async");
        this.startAsyncButton.add_Click(
            new System.EventHandler(this.startAsyncButton_Click));

        // 
        // cancelAsyncButton
        // 
        this.cancelAsyncButton.set_Enabled(false);
        this.cancelAsyncButton.set_Location(new System.Drawing.Point(153, 72));
        this.cancelAsyncButton.set_Name("cancelAsyncButton");
        this.cancelAsyncButton.set_Size(new System.Drawing.Size(119, 23));
        this.cancelAsyncButton.set_TabIndex(2);
        this.cancelAsyncButton.set_Text("Cancel Async");
        this.cancelAsyncButton.add_Click(
            new System.EventHandler(this.cancelAsyncButton_Click));

        // 
        // resultLabel
        // 
        this.resultLabel.set_BorderStyle(System.Windows.Forms.BorderStyle.Fixed3D);
        this.resultLabel.set_Location(new System.Drawing.Point(112, 16));
        this.resultLabel.set_Name("resultLabel");
        this.resultLabel.set_Size(new System.Drawing.Size(160, 23));
        this.resultLabel.set_TabIndex(3);
        this.resultLabel.set_Text("(no result)");
        this.resultLabel.set_TextAlign(System.Drawing.ContentAlignment.MiddleCenter);

        // 
        // progressBar1
        // 
        this.progressBar1.set_Location(new System.Drawing.Point(18, 48));
        this.progressBar1.set_Name("progressBar1");
        this.progressBar1.set_Size(new System.Drawing.Size(256, 8));
        this.progressBar1.set_Step(2);
        this.progressBar1.set_TabIndex(4);

        // 
        // backgroundWorker1
        // 
        this.backgroundWorker1.set_WorkerReportsProgress(true);
        this.backgroundWorker1.set_WorkerSupportsCancellation(true);

        // 
        // FibonacciForm
        // 
        this.set_ClientSize(new System.Drawing.Size(292, 118));
        this.get_Controls().Add(this.progressBar1);
        this.get_Controls().Add(this.resultLabel);
        this.get_Controls().Add(this.cancelAsyncButton);
        this.get_Controls().Add(this.startAsyncButton);
        this.get_Controls().Add(this.numericUpDown1);
        this.set_Name("FibonacciForm");
        this.set_Text("Fibonacci Calculator");
        ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).
            EndInit();
        this.ResumeLayout(false);
    } //InitializeComponent
    #endregion

    /** @attribute STAThread()
     */
    public static void main(String[] args)
    {
        Application.Run(new FibonacciForm());
    } //main
} //FibonacciForm



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

Quaisquer membros públicos estático (compartilhados na Visual Basic) desse tipo são Thread seguro. Não há garantia de que qualquer membro de instância seja isento de segmentos.

Contribuições da comunidade

ADICIONAR
Mostrar: