BackgroundWorker Kelas

Definisi

Ruang nama:

System.ComponentModel

Rakitan:

netstandard.dll, System.ComponentModel.EventBasedAsync.dll

Sumber:

BackgroundWorker.cs

Menjalankan operasi pada utas terpisah.

public ref class BackgroundWorker : System::ComponentModel::Component

public class BackgroundWorker : System.ComponentModel.Component

type BackgroundWorker = class
    inherit Component

Public Class BackgroundWorker
Inherits Component

Warisan

Object

MarshalByRefObject

Component

BackgroundWorker

Contoh

Contoh kode berikut menunjukkan dasar-dasar BackgroundWorker kelas untuk menjalankan operasi yang memakan waktu secara asinkron. Ilustrasi berikut menunjukkan contoh output.

Untuk mencoba kode ini, buat aplikasi Windows Forms. Label Tambahkan kontrol bernama resultLabel dan tambahkan dua Button kontrol bernama startAsyncButton dan cancelAsyncButton. Buat Click penanganan aktivitas untuk kedua tombol. Dari tab Komponen kotak Alat, tambahkan BackgroundWorker komponen bernama backgroundWorker1. Buat DoWork, ProgressChanged, dan RunWorkerCompleted penanganan aktivitas untuk BackgroundWorker. Dalam kode untuk formulir, ganti kode yang ada dengan kode berikut.

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

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

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

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

        for (int i = 1; i <= 10; i++)
        {
            if (worker.CancellationPending)
            {
                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.
    void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e) =>
        resultLabel.Text = e.ProgressPercentage.ToString() + "%";

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

Imports System.ComponentModel

Public Class Form1

    Public Sub New()
        InitializeComponent()
        backgroundWorker1.WorkerReportsProgress = True
        backgroundWorker1.WorkerSupportsCancellation = True
    End Sub

    Private Sub startAsyncButton_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles startAsyncButton.Click
        If Not backgroundWorker1.IsBusy Then
            ' Start the asynchronous operation.
            backgroundWorker1.RunWorkerAsync()
        End If
    End Sub

    Private Sub cancelAsyncButton_Click(ByVal sender As System.Object, _
    ByVal e As System.EventArgs) Handles cancelAsyncButton.Click
        If backgroundWorker1.WorkerSupportsCancellation Then
            ' Cancel the asynchronous operation.
            backgroundWorker1.CancelAsync()
        End If
    End Sub

    ' This event handler is where the time-consuming work is done.
    Private Sub backgroundWorker1_DoWork(ByVal sender As System.Object, _
    ByVal e As DoWorkEventArgs) Handles backgroundWorker1.DoWork
        Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)
        Dim i As Integer

        For i = 1 To 10
            If (worker.CancellationPending) Then
                e.Cancel = True
                Exit For
            Else
                ' Perform a time consuming operation and report progress.
                System.Threading.Thread.Sleep(500)
                worker.ReportProgress(i * 10)
            End If
        Next
    End Sub

    ' This event handler updates the progress.
    Private Sub backgroundWorker1_ProgressChanged(ByVal sender As System.Object, _
    ByVal e As ProgressChangedEventArgs) Handles backgroundWorker1.ProgressChanged
        resultLabel.Text = (e.ProgressPercentage.ToString() + "%")
    End Sub

    ' This event handler deals with the results of the background operation.
    Private Sub backgroundWorker1_RunWorkerCompleted(ByVal sender As System.Object, _
    ByVal e As RunWorkerCompletedEventArgs) Handles backgroundWorker1.RunWorkerCompleted
        If e.Cancelled Then
            resultLabel.Text = "Canceled!"
        ElseIf e.Error IsNot Nothing Then
            resultLabel.Text = "Error: " & e.Error.Message
        Else
            resultLabel.Text = "Done!"
        End If
    End Sub
End Class

Contoh kode berikut menunjukkan penggunaan BackgroundWorker kelas untuk menjalankan operasi yang memakan waktu secara asinkron. Ilustrasi berikut menunjukkan contoh output.

Operasi ini menghitung nomor Fibonacci yang dipilih, melaporkan pembaruan kemajuan saat penghitungan berlanjut, dan mengizinkan penghitungan yang tertunda untuk dibatalkan.

#using <System.Drawing.dll>
#using <System.dll>
#using <System.Windows.Forms.dll>

using namespace System;
using namespace System::Collections;
using namespace System::ComponentModel;
using namespace System::Drawing;
using namespace System::Threading;
using namespace System::Windows::Forms;

public ref class FibonacciForm: public System::Windows::Forms::Form
{
private:

   int numberToCompute;
   int highestPercentageReached;

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

public:
   FibonacciForm()
   {
      InitializeComponent();
      numberToCompute = highestPercentageReached = 0;
      InitializeBackgoundWorker();
   }


private:

   // Set up the BackgroundWorker object by 
   // attaching event handlers. 
   void InitializeBackgoundWorker()
   {
      backgroundWorker1->DoWork += gcnew DoWorkEventHandler( this, &FibonacciForm::backgroundWorker1_DoWork );
      backgroundWorker1->RunWorkerCompleted += gcnew RunWorkerCompletedEventHandler( this, &FibonacciForm::backgroundWorker1_RunWorkerCompleted );
      backgroundWorker1->ProgressChanged += gcnew ProgressChangedEventHandler( this, &FibonacciForm::backgroundWorker1_ProgressChanged );
   }

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

   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.
   void backgroundWorker1_DoWork( Object^ sender, DoWorkEventArgs^ e )
   {
      // Get the BackgroundWorker that raised this event.
      BackgroundWorker^ worker = dynamic_cast<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->Result = ComputeFibonacci( safe_cast<Int32>(e->Argument), worker, e );
   }

   // This event handler deals with the results of the
   // background operation.
   void backgroundWorker1_RunWorkerCompleted( Object^ /*sender*/, RunWorkerCompletedEventArgs^ e )
   {
      // First, handle the case where an exception was thrown.
      if ( e->Error != nullptr )
      {
         MessageBox::Show( e->Error->Message );
      }
      else
      if ( e->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->Text = "Cancelled";
      }
      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.
   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 gcnew 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->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;
   }

   void InitializeComponent()
   {
      this->numericUpDown1 = gcnew System::Windows::Forms::NumericUpDown;
      this->startAsyncButton = gcnew System::Windows::Forms::Button;
      this->cancelAsyncButton = gcnew System::Windows::Forms::Button;
      this->resultLabel = gcnew System::Windows::Forms::Label;
      this->progressBar1 = gcnew System::Windows::Forms::ProgressBar;
      this->backgroundWorker1 = gcnew System::ComponentModel::BackgroundWorker;
      (dynamic_cast<System::ComponentModel::ISupportInitialize^>(this->numericUpDown1))->BeginInit();
      this->SuspendLayout();
      
      // 
      // numericUpDown1
      // 
      this->numericUpDown1->Location = System::Drawing::Point( 16, 16 );
      array<Int32>^temp0 = {91,0,0,0};
      this->numericUpDown1->Maximum = System::Decimal( temp0 );
      array<Int32>^temp1 = {1,0,0,0};
      this->numericUpDown1->Minimum = System::Decimal( temp1 );
      this->numericUpDown1->Name = "numericUpDown1";
      this->numericUpDown1->Size = System::Drawing::Size( 80, 20 );
      this->numericUpDown1->TabIndex = 0;
      array<Int32>^temp2 = {1,0,0,0};
      this->numericUpDown1->Value = System::Decimal( temp2 );

      // 
      // startAsyncButton
      // 
      this->startAsyncButton->Location = System::Drawing::Point( 16, 72 );
      this->startAsyncButton->Name = "startAsyncButton";
      this->startAsyncButton->Size = System::Drawing::Size( 120, 23 );
      this->startAsyncButton->TabIndex = 1;
      this->startAsyncButton->Text = "Start Async";
      this->startAsyncButton->Click += gcnew System::EventHandler( this, &FibonacciForm::startAsyncButton_Click );

      // 
      // cancelAsyncButton
      // 
      this->cancelAsyncButton->Enabled = false;
      this->cancelAsyncButton->Location = System::Drawing::Point( 153, 72 );
      this->cancelAsyncButton->Name = "cancelAsyncButton";
      this->cancelAsyncButton->Size = System::Drawing::Size( 119, 23 );
      this->cancelAsyncButton->TabIndex = 2;
      this->cancelAsyncButton->Text = "Cancel Async";
      this->cancelAsyncButton->Click += gcnew System::EventHandler( this, &FibonacciForm::cancelAsyncButton_Click );

      // 
      // resultLabel
      // 
      this->resultLabel->BorderStyle = System::Windows::Forms::BorderStyle::Fixed3D;
      this->resultLabel->Location = System::Drawing::Point( 112, 16 );
      this->resultLabel->Name = "resultLabel";
      this->resultLabel->Size = 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 = System::Drawing::Point( 18, 48 );
      this->progressBar1->Name = "progressBar1";
      this->progressBar1->Size = 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 = 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";
      (dynamic_cast<System::ComponentModel::ISupportInitialize^>(this->numericUpDown1))->EndInit();
      this->ResumeLayout( false );
   }
};

[STAThread]
int main()
{
   Application::Run( gcnew FibonacciForm );
}

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

namespace BackgroundWorkerExample;

public class FibonacciForm : Form
{
    int numberToCompute;
    int highestPercentageReached;

    NumericUpDown numericUpDown1;
    Button startAsyncButton;
    Button cancelAsyncButton;
    ProgressBar progressBar1;
    Label resultLabel;
    BackgroundWorker backgroundWorker1;

    public FibonacciForm()
    {
        InitializeComponent();

        InitializeBackgroundWorker();
    }

    // Set up the BackgroundWorker object by 
    // attaching event handlers. 
    void InitializeBackgroundWorker()
    {
        backgroundWorker1.DoWork +=
             backgroundWorker1_DoWork;
        backgroundWorker1.RunWorkerCompleted +=

        backgroundWorker1_RunWorkerCompleted;
        backgroundWorker1.ProgressChanged +=

        backgroundWorker1_ProgressChanged;
    }

    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.
        numericUpDown1.Enabled = false;

        // Disable the Start button until 
        // the asynchronous operation is done.
        startAsyncButton.Enabled = false;

        // Enable the Cancel button while 
        // the asynchronous operation runs.
        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);
    }

    void cancelAsyncButton_Click(object sender,
        EventArgs e)
    {
        // Cancel the asynchronous operation.
        backgroundWorker1.CancelAsync();

        // Disable the Cancel button.
        cancelAsyncButton.Enabled = false;
    }

    // This event handler is where the actual,
    // potentially time-consuming work is done.
    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.
    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.
        numericUpDown1.Enabled = true;

        // Enable the Start button.
        startAsyncButton.Enabled = true;

        // Disable the Cancel button.
        cancelAsyncButton.Enabled = false;
    }

    // This event handler updates the progress bar.
    void backgroundWorker1_ProgressChanged(object sender,
        ProgressChangedEventArgs e) => 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 is < 0 or > 91)
        {
            throw new ArgumentException(
                "value must be >= 0 and <= 91", nameof(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
        {
            result = n < 2
                ? 1
                : ComputeFibonacci(n - 1, worker, e) +
                         ComputeFibonacci(n - 2, worker, e);

            // Report progress as a percentage of the total task.
            int percentComplete =
                (int)(n / (float)numberToCompute * 100);
            if (percentComplete > highestPercentageReached)
            {
                highestPercentageReached = percentComplete;
                worker.ReportProgress(percentComplete);
            }
        }

        return result;
    }

    #region Windows Form Designer generated code

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

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

Imports System.ComponentModel
Imports System.Windows.Forms

Public Class FibonacciForm
    Inherits Form

    Private numberToCompute As Integer = 0
    Private highestPercentageReached As Integer = 0

    Private numericUpDown1 As NumericUpDown
    Private WithEvents startAsyncButton As Button
    Private WithEvents cancelAsyncButton As Button
    Private progressBar1 As ProgressBar
    Private resultLabel As Label
    Private WithEvents backgroundWorker1 As System.ComponentModel.BackgroundWorker


    Public Sub New()
        InitializeComponent()
    End Sub

    Private Sub startAsyncButton_Click(ByVal sender As System.Object,
    ByVal e As System.EventArgs) _
    Handles startAsyncButton.Click

        ' Reset the text in the result label.
        resultLabel.Text = [String].Empty

        ' Disable the UpDown control until 
        ' the asynchronous operation is done.
        numericUpDown1.Enabled = False

        ' Disable the Start button until 
        ' the asynchronous operation is done.
        startAsyncButton.Enabled = False

        ' Enable the Cancel button while 
        ' the asynchronous operation runs.
        cancelAsyncButton.Enabled = True

        ' Get the value from the UpDown control.
        numberToCompute = CInt(numericUpDown1.Value)

        ' Reset the variable for percentage tracking.
        highestPercentageReached = 0


        ' Start the asynchronous operation.
        backgroundWorker1.RunWorkerAsync(numberToCompute)
    End Sub

    Private Sub cancelAsyncButton_Click(
    ByVal sender As System.Object,
    ByVal e As System.EventArgs) _
    Handles cancelAsyncButton.Click

        ' Cancel the asynchronous operation.
        backgroundWorker1.CancelAsync()

        ' Disable the Cancel button.
        cancelAsyncButton.Enabled = False

    End Sub

    ' This event handler is where the actual work is done.
    Private Sub backgroundWorker1_DoWork(
    ByVal sender As Object,
    ByVal e As DoWorkEventArgs) _
    Handles backgroundWorker1.DoWork

        ' Get the BackgroundWorker object that raised this event.
        Dim worker As BackgroundWorker =
            CType(sender, 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(e.Argument, worker, e)
    End Sub

    ' This event handler deals with the results of the
    ' background operation.
    Private Sub backgroundWorker1_RunWorkerCompleted(
    ByVal sender As Object, ByVal e As RunWorkerCompletedEventArgs) _
    Handles backgroundWorker1.RunWorkerCompleted

        ' First, handle the case where an exception was thrown.
        If (e.Error IsNot Nothing) Then
            MessageBox.Show(e.Error.Message)
        ElseIf e.Cancelled Then
            ' 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()
        End If

        ' Enable the UpDown control.
        numericUpDown1.Enabled = True

        ' Enable the Start button.
        startAsyncButton.Enabled = True

        ' Disable the Cancel button.
        cancelAsyncButton.Enabled = False
    End Sub

    ' This event handler updates the progress bar.
    Private Sub backgroundWorker1_ProgressChanged(
    ByVal sender As Object, ByVal e As ProgressChangedEventArgs) _
    Handles backgroundWorker1.ProgressChanged

        progressBar1.Value = e.ProgressPercentage

    End Sub

    ' 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.
    Function ComputeFibonacci(
        ByVal n As Integer,
        ByVal worker As BackgroundWorker,
        ByVal e As DoWorkEventArgs) As Long

        ' The parameter n must be >= 0 and <= 91.
        ' Fib(n), with n > 91, overflows a long.
        If n < 0 OrElse n > 91 Then
            Throw New ArgumentException(
                "value must be >= 0 and <= 91", "n")
        End If

        Dim result As Long = 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 Then
            e.Cancel = True
        Else
            If n < 2 Then
                result = 1
            Else
                result = ComputeFibonacci(n - 1, worker, e) +
                         ComputeFibonacci(n - 2, worker, e)
            End If

            ' Report progress as a percentage of the total task.
            Dim percentComplete As Integer =
                CSng(n) / CSng(numberToCompute) * 100
            If percentComplete > highestPercentageReached Then
                highestPercentageReached = percentComplete
                worker.ReportProgress(percentComplete)
            End If

        End If

        Return result

    End Function


    Private Sub InitializeComponent()
        numericUpDown1 = New NumericUpDown
        startAsyncButton = New Button
        cancelAsyncButton = New Button
        resultLabel = New Label
        progressBar1 = New ProgressBar
        backgroundWorker1 = New System.ComponentModel.BackgroundWorker
        CType(numericUpDown1, System.ComponentModel.ISupportInitialize).BeginInit()
        SuspendLayout()
        '
        'numericUpDown1
        '
        numericUpDown1.Location = New System.Drawing.Point(16, 16)
        numericUpDown1.Maximum = New Decimal(New Integer() {91, 0, 0, 0})
        numericUpDown1.Minimum = New Decimal(New Integer() {1, 0, 0, 0})
        numericUpDown1.Name = "numericUpDown1"
        numericUpDown1.Size = New System.Drawing.Size(80, 20)
        numericUpDown1.TabIndex = 0
        numericUpDown1.Value = New Decimal(New Integer() {1, 0, 0, 0})
        '
        'startAsyncButton
        '
        startAsyncButton.Location = New System.Drawing.Point(16, 72)
        startAsyncButton.Name = "startAsyncButton"
        startAsyncButton.Size = New System.Drawing.Size(120, 23)
        startAsyncButton.TabIndex = 1
        startAsyncButton.Text = "Start Async"
        '
        'cancelAsyncButton
        '
        cancelAsyncButton.Enabled = False
        cancelAsyncButton.Location = New System.Drawing.Point(153, 72)
        cancelAsyncButton.Name = "cancelAsyncButton"
        cancelAsyncButton.Size = New System.Drawing.Size(119, 23)
        cancelAsyncButton.TabIndex = 2
        cancelAsyncButton.Text = "Cancel Async"
        '
        'resultLabel
        '
        resultLabel.BorderStyle = BorderStyle.Fixed3D
        resultLabel.Location = New System.Drawing.Point(112, 16)
        resultLabel.Name = "resultLabel"
        resultLabel.Size = New System.Drawing.Size(160, 23)
        resultLabel.TabIndex = 3
        resultLabel.Text = "(no result)"
        resultLabel.TextAlign = System.Drawing.ContentAlignment.MiddleCenter
        '
        'progressBar1
        '
        progressBar1.Location = New System.Drawing.Point(18, 48)
        progressBar1.Name = "progressBar1"
        progressBar1.Size = New System.Drawing.Size(256, 8)
        progressBar1.TabIndex = 4
        '
        'backgroundWorker1
        '
        backgroundWorker1.WorkerReportsProgress = True
        backgroundWorker1.WorkerSupportsCancellation = True
        '
        'FibonacciForm
        '
        ClientSize = New System.Drawing.Size(292, 118)
        Controls.Add(progressBar1)
        Controls.Add(resultLabel)
        Controls.Add(cancelAsyncButton)
        Controls.Add(startAsyncButton)
        Controls.Add(numericUpDown1)
        Name = "FibonacciForm"
        Text = "Fibonacci Calculator"
        CType(numericUpDown1, System.ComponentModel.ISupportInitialize).EndInit()
        ResumeLayout(False)

    End Sub

    <STAThread()> _
    Shared Sub Main()
        Application.Run(New FibonacciForm)
    End Sub
End Class

Keterangan

Kelas ini BackgroundWorker memungkinkan Anda menjalankan operasi pada utas khusus yang terpisah. Operasi yang memakan waktu seperti unduhan dan transaksi database dapat menyebabkan antarmuka pengguna (UI) Anda tampak seolah-olah telah berhenti merespons saat mereka berjalan. Ketika Anda menginginkan UI responsif dan Anda dihadapkan dengan penundaan panjang yang terkait dengan operasi tersebut BackgroundWorker , kelas menyediakan solusi yang nyaman.

Untuk menjalankan operasi yang memakan waktu di latar belakang, buat BackgroundWorker dan dengarkan peristiwa yang melaporkan kemajuan operasi dan sinyal Anda saat operasi Anda selesai. Anda dapat membuat BackgroundWorker secara terprogram atau Anda dapat menyeretnya ke formulir Anda dari tab Komponen kotak Alat. Jika Anda membuat BackgroundWorker di Windows Forms Designer, itu akan muncul di Baki Komponen, dan propertinya akan ditampilkan di jendela Properti.

Untuk menyiapkan operasi latar belakang, tambahkan penanganan aktivitas untuk peristiwa tersebut DoWork . Panggil operasi yang memakan waktu Anda di penanganan aktivitas ini. Untuk memulai operasi, panggil RunWorkerAsync. Untuk menerima pemberitahuan pembaruan kemajuan, tangani ProgressChanged peristiwa. Untuk menerima pemberitahuan saat operasi selesai, tangani RunWorkerCompleted peristiwa.

Nota

Anda harus berhati-hati agar tidak memanipulasi objek antarmuka pengguna apa pun di penanganan aktivitas Anda DoWork . Sebagai gantinya, komunikasikan ke antarmuka pengguna melalui ProgressChanged peristiwa dan RunWorkerCompleted .

BackgroundWorker peristiwa tidak dirusak di seluruh AppDomain batas. Jangan gunakan BackgroundWorker komponen untuk melakukan operasi multithreaded di lebih dari satu AppDomain.

Jika operasi latar belakang Anda memerlukan parameter, panggil RunWorkerAsync dengan parameter Anda. Di dalam penanganan DoWork aktivitas, Anda dapat mengekstrak parameter dari DoWorkEventArgs.Argument properti .

Untuk informasi selengkapnya tentang BackgroundWorker, lihat Cara: Menjalankan Operasi di Latar Belakang.

Konstruktor

Nama	Deskripsi
BackgroundWorker()	Menginisialisasi instans baru dari kelas BackgroundWorker.

Properti

Nama	Deskripsi
CancellationPending	Mendapatkan nilai yang menunjukkan apakah aplikasi telah meminta pembatalan operasi latar belakang.
CanRaiseEvents	Mendapatkan nilai yang menunjukkan apakah komponen dapat menaikkan peristiwa. (Diperoleh dari Component)
Container	IContainer Mendapatkan yang berisi Component. (Diperoleh dari Component)
DesignMode	Mendapatkan nilai yang menunjukkan apakah Component saat ini dalam mode desain. (Diperoleh dari Component)
Events	Mendapatkan daftar penanganan aktivitas yang dilampirkan ke ini Component. (Diperoleh dari Component)
IsBusy	Mendapatkan nilai yang menunjukkan apakah BackgroundWorker menjalankan operasi asinkron.
Site	Mendapatkan atau mengatur ISite dari Component. (Diperoleh dari Component)
WorkerReportsProgress	Mendapatkan atau menetapkan nilai yang menunjukkan apakah BackgroundWorker dapat melaporkan pembaruan kemajuan.
WorkerSupportsCancellation	Mendapatkan atau menetapkan nilai yang menunjukkan apakah BackgroundWorker mendukung pembatalan asinkron.

Metode

Nama	Deskripsi
CancelAsync()	Meminta pembatalan operasi latar belakang yang tertunda.
Dispose()	Merilis semua sumber daya yang Componentdigunakan oleh . (Diperoleh dari Component)
Dispose(Boolean)	Metode ini tidak melakukan apa pun.
Equals(Object)	Menentukan apakah objek yang ditentukan sama dengan objek saat ini. (Diperoleh dari Object)
GetHashCode()	Berfungsi sebagai fungsi hash default. (Diperoleh dari Object)
GetLifetimeService()	Kedaluwarsa. Mengambil objek layanan seumur hidup saat ini yang mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
GetService(Type)	Mengembalikan objek yang mewakili layanan yang disediakan oleh Component atau oleh Container. (Diperoleh dari Component)
GetType()	Mendapatkan Type instans saat ini. (Diperoleh dari Object)
InitializeLifetimeService()	Kedaluwarsa. Mendapatkan objek layanan seumur hidup untuk mengontrol kebijakan seumur hidup untuk instans ini. (Diperoleh dari MarshalByRefObject)
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
MemberwiseClone(Boolean)	Membuat salinan dangkal objek saat ini MarshalByRefObject . (Diperoleh dari MarshalByRefObject)
OnDoWork(DoWorkEventArgs)	Menaikkan DoWork acara.
OnProgressChanged(ProgressChangedEventArgs)	Menaikkan ProgressChanged acara.
OnRunWorkerCompleted(RunWorkerCompletedEventArgs)	Menaikkan RunWorkerCompleted acara.
ReportProgress(Int32, Object)	Menaikkan ProgressChanged acara.
ReportProgress(Int32)	Menaikkan ProgressChanged acara.
RunWorkerAsync()	Memulai eksekusi operasi latar belakang.
RunWorkerAsync(Object)	Memulai eksekusi operasi latar belakang.
ToString()	Mengembalikan yang String berisi nama Component, jika ada. Metode ini tidak boleh ditimpa. (Diperoleh dari Component)

Acara

Nama	Deskripsi
Disposed	Terjadi ketika komponen dibuang oleh panggilan ke Dispose() metode . (Diperoleh dari Component)
DoWork	Terjadi ketika RunWorkerAsync() dipanggil.
ProgressChanged	Terjadi ketika ReportProgress(Int32) dipanggil.
RunWorkerCompleted	Terjadi ketika operasi latar belakang telah selesai, telah dibatalkan, atau telah memunculkan pengecualian.

Lihat juga

• Cara Menjalankan Operasi di Latar Belakang
• Praktik Terbaik Penguliran Terkelola
• Cara: Mengunduh File di Latar Belakang