Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Classe BackgroundWorker

 

Data di pubblicazione: ottobre 2016

Esegue un'operazione su un thread separato.

Spazio dei nomi:   System.ComponentModel
Assembly:  System (in System.dll)

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

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

NomeDescrizione
System_CAPS_pubmethodBackgroundWorker()

Inizializza una nuova istanza della classe BackgroundWorker.

NomeDescrizione
System_CAPS_pubpropertyCancellationPending

Ottiene un valore che indica se l'applicazione ha richiesto l'annullamento di un'operazione in background.

System_CAPS_protpropertyCanRaiseEvents

Ottiene un valore che indica se il componente può generare un evento.(Ereditato da Component.)

System_CAPS_pubpropertyContainer

Ottiene il IContainer che contiene il Component.(Ereditato da Component.)

System_CAPS_protpropertyDesignMode

Ottiene un valore che indica se il Component è attualmente in modalità progettazione.(Ereditato da Component.)

System_CAPS_protpropertyEvents

Ottiene l'elenco di gestori eventi associati a questo Component.(Ereditato da Component.)

System_CAPS_pubpropertyIsBusy

Ottiene un valore che indica se il BackgroundWorker è in esecuzione un'operazione asincrona.

System_CAPS_pubpropertySite

Ottiene o imposta il ISite di Component.(Ereditato da Component.)

System_CAPS_pubpropertyWorkerReportsProgress

Ottiene o imposta un valore che indica se il BackgroundWorker può segnalare gli aggiornamenti sull'avanzamento.

System_CAPS_pubpropertyWorkerSupportsCancellation

Ottiene o imposta un valore che indica se il BackgroundWorker supporta l'annullamento asincrono.

NomeDescrizione
System_CAPS_pubmethodCancelAsync()

Richiede l'annullamento di un'operazione in background in sospeso.

System_CAPS_pubmethodCreateObjRef(Type^)

Crea un oggetto che contiene le informazioni necessarie per generare un proxy utilizzato per comunicare con un oggetto remoto.(Ereditato da MarshalByRefObject.)

System_CAPS_pubmethodDispose()

Rilascia tutte le risorse usate da Component.(Ereditato da Component.)

System_CAPS_protmethodDispose(Boolean)

Rilascia le risorse non gestite usate da Component e, facoltativamente, le risorse gestite.(Ereditato da Component.)

System_CAPS_pubmethodEquals(Object^)

Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object.)

System_CAPS_protmethodFinalize()

Rilascia risorse non gestite ed esegue altre operazioni di pulizia prima che la classe Component venga recuperata tramite Garbage Collection.(Ereditato da Component.)

System_CAPS_pubmethodGetHashCode()

Funge da funzione hash predefinita.(Ereditato da Object.)

System_CAPS_pubmethodGetLifetimeService()

Recupera l'oggetto servizio di durata corrente che controlla i criteri di durata per questa istanza.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodGetService(Type^)

Consente di restituire un oggetto che rappresenta un servizio fornito da Component o dal relativo Container.(Ereditato da Component.)

System_CAPS_pubmethodGetType()

Ottiene l'oggetto Type dell'istanza corrente.(Ereditato da Object.)

System_CAPS_pubmethodInitializeLifetimeService()

Ottiene un oggetto servizio di durata per controllare i criteri di durata per questa istanza.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodMemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.(Ereditato da Object.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Crea una copia superficiale dell'oggetto corrente MarshalByRefObject oggetto.(Ereditato da MarshalByRefObject.)

System_CAPS_protmethodOnDoWork(DoWorkEventArgs^)

Genera l'evento DoWork.

System_CAPS_protmethodOnProgressChanged(ProgressChangedEventArgs^)

Genera l'evento ProgressChanged.

System_CAPS_protmethodOnRunWorkerCompleted(RunWorkerCompletedEventArgs^)

Genera l'evento RunWorkerCompleted.

System_CAPS_pubmethodReportProgress(Int32)

Genera l'evento ProgressChanged.

System_CAPS_pubmethodReportProgress(Int32, Object^)

Genera l'evento ProgressChanged.

System_CAPS_pubmethodRunWorkerAsync()

Avvia l'esecuzione di un'operazione in background.

System_CAPS_pubmethodRunWorkerAsync(Object^)

Avvia l'esecuzione di un'operazione in background.

System_CAPS_pubmethodToString()

Restituisce un String contenente il nome del Component, se presente. Questo metodo non deve essere sottoposto a override.(Ereditato da Component.)

NomeDescrizione
System_CAPS_pubeventDisposed

Si verifica quando il componente viene eliminato da una chiamata al Dispose metodo.(Ereditato da Component.)

System_CAPS_pubeventDoWork

Si verifica quando RunWorkerAsync viene chiamato.

System_CAPS_pubeventProgressChanged

Si verifica quando ReportProgress viene chiamato.

System_CAPS_pubeventRunWorkerCompleted

Si verifica quando l'operazione in background è stata completata, annullata o ha generato un'eccezione.

La BackgroundWorker classe consente di eseguire un'operazione su un thread dedicato separato. Operazioni impegnative come download e le transazioni di database possono causare l'interfaccia utente (UI) sembri non rispondere durante l'esecuzione. Quando si desidera un'interfaccia utente reattiva e si vogliano evitare ritardi associati a tali operazioni, la BackgroundWorker classe costituisce la soluzione ideale.

Per eseguire un'operazione impegnativa in background, creare un BackgroundWorker e rimanere in ascolto degli eventi che segnalano lo stato di avanzamento dell'operazione e ne indicano quando l'operazione è stata completata. È possibile creare il BackgroundWorker a livello di codice o è possibile trascinare il modulo del componenti scheda il della casella degli strumenti. Se si crea il BackgroundWorker in Progettazione Windows Form, essa verrà visualizzata nella barra dei componenti e le relative proprietà verranno visualizzate nella finestra Proprietà.

Per impostare un'operazione in background, aggiungere un gestore eventi per il DoWork evento. In questo gestore eventi, chiamare l'operazione desiderata. Per avviare l'operazione, chiamare RunWorkerAsync. Per ricevere notifiche di aggiornamenti di stato di avanzamento, gestire il ProgressChanged evento. Per ricevere una notifica quando l'operazione è completata, gestire il RunWorkerCompleted evento.

System_CAPS_noteNota

È necessario evitare di modificare tutti gli oggetti dell'interfaccia utente nel DoWork gestore dell'evento. Comunicare invece con l'interfaccia utente attraverso il ProgressChanged e RunWorkerCompleted gli eventi.

BackgroundWorker gli eventi non vengono eseguito il marshalling tra AppDomain limiti. Non utilizzare un BackgroundWorker componente per eseguire operazioni a thread multipli in più AppDomain.

Se l'operazione in background richiede un parametro, chiamare RunWorkerAsync con il parametro. All'interno di DoWork gestore dell'evento, è possibile estrarre il parametro la DoWorkEventArgs::Argument proprietà.

Per altre informazioni su BackgroundWorker, vedere Procedura: eseguire un'operazione in background.

L'esempio di codice seguente illustra le nozioni di base di BackgroundWorker classe per l'esecuzione di un'operazione impegnativa in modo asincrono. Nella figura seguente viene illustrato un esempio dell'output.

Esempio di BackgroundWorker semplice

Per eseguire questo codice, creare un'applicazione Windows Form. Aggiungere un Label controllo denominato resultLabel e aggiungere due Button controlli denominati startAsyncButton e cancelAsyncButton. Creare Click gestori eventi per entrambi i pulsanti. Dal componenti scheda casella degli strumenti, aggiungere un BackgroundWorker componente denominato backgroundWorker1. Creare DoWork, ProgressChanged, e RunWorkerCompleted i gestori eventi per il BackgroundWorker. Nel codice per il form, sostituire il codice esistente con il codice seguente.

Non sono attualmente disponibili esempi di codice o questo linguaggio potrebbe non essere supportato.

Esempio di codice riportato di seguito viene illustrato l'utilizzo della BackgroundWorker classe per l'esecuzione di un'operazione impegnativa in modo asincrono. Nella figura seguente viene illustrato un esempio dell'output.

Esempio di BackgroundWorker con calcolo della sequenza di Fibonacci

L'operazione calcola il numero di Fibonacci selezionato, segnala gli aggiornamenti di stato di avanzamento durante il calcolo e consente un calcolo in sospeso da annullare.

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

Universal Windows Platform
Disponibile da 10
.NET Framework
Disponibile da 2.0
Silverlight
Disponibile da 2.0
Windows Phone Silverlight
Disponibile da 7.0

I membri statici pubblici ( Condiviso in Visual Basic) di questo tipo è thread safe. Non tutti i membri di istanza sono garantiti come thread safe.

Torna all'inizio
Mostra: