Esporta (0) Stampa
Espandi tutto
Il presente articolo è stato tradotto automaticamente. Passare il puntatore sulle frasi nell'articolo per visualizzare il testo originale. Ulteriori informazioni.
Traduzione
Originale

Classe BackgroundWorker

esegue un'operazione su un thread separato.

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

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

Il tipo BackgroundWorker espone i seguenti membri.

  NomeDescrizione
Metodo pubblicoBackgroundWorkerInizializza una nuova istanza di BackgroundWorker classe.
In alto

  NomeDescrizione
Proprietà pubblicaCancellationPendingottiene un valore che indica se l'applicazione ha richiesto l'annullamento di un'operazione in background.
Proprietà protetta.CanRaiseEventsOttiene un valore che indica se il componente può generare un evento. (Ereditato da Component)
Proprietà pubblicaContainerottiene IContainer contenente Component. (Ereditato da Component)
Proprietà protetta.DesignModeottiene un valore che indica se Component si trova in modalità progettazione. (Ereditato da Component)
Proprietà protetta.EventsOttiene l'elenco dei gestori eventi associati a questo Component. (Ereditato da Component)
Proprietà pubblicaIsBusyottiene un valore che indica se BackgroundWorker esegue un'operazione asincrona.
Proprietà pubblicaSiteottiene o imposta ISite il Component. (Ereditato da Component)
Proprietà pubblicaWorkerReportsProgressOttiene o imposta un valore che indica se BackgroundWorker può segnalare gli aggiornamenti di stato.
Proprietà pubblicaWorkerSupportsCancellationOttiene o imposta un valore che indica se BackgroundWorker supporta l'annullamento asincrono.
In alto

  NomeDescrizione
Metodo pubblicoCancelAsyncRichiede l'annullamento di un di un'operazione in background in attesa.
Metodo pubblicoCreateObjRefCrea un oggetto che contiene tutte le informazioni rilevanti obbligatorio per generare un proxy utilizzato per comunicare con un oggetto remoto. (Ereditato da MarshalByRefObject)
Metodo pubblicoDispose()Libera tutte le risorse utilizzate da Component. (Ereditato da Component)
Metodo protettoDispose(Boolean)Rilascia risorse non gestite utilizzate da Component e facoltativamente dealloca risorse gestite. (Ereditato da Component)
Metodo pubblicoEquals(Object) Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
Metodo protettoFinalizeRilascia risorse non gestite e l'esecuzione di altre operazioni di pulitura prima di Component viene recuperato dalla Garbage Collection. (Ereditato da Component)
Metodo pubblicoGetHashCode Funge da funzione hash per un particolare tipo. (Ereditato da Object)
Metodo pubblicoGetLifetimeServiceRecupera l'oggetto corrente del servizio di durata che controlla i criteri di durata dell'istanza. (Ereditato da MarshalByRefObject)
Metodo protettoGetServiceRestituisce un oggetto che rappresenta un servizio fornito da Component o dal Container. (Ereditato da Component)
Metodo pubblicoGetType Ottiene il Type dell'istanza corrente. (Ereditato da Object)
Metodo pubblicoInitializeLifetimeServiceOttiene un oggetto di servizio di durata per controllare i criteri di durata dell'istanza. (Ereditato da MarshalByRefObject)
Metodo protettoMemberwiseClone() Crea una copia dei riferimenti dell'oggetto Object corrente. (Ereditato da Object)
Metodo protettoMemberwiseClone(Boolean)Crea una copia superficiale corrente MarshalByRefObject oggetto. (Ereditato da MarshalByRefObject)
Metodo protettoOnDoWorkGenerato DoWork evento.
Metodo protettoOnProgressChangedGenerato ProgressChanged evento.
Metodo protettoOnRunWorkerCompletedGenerato RunWorkerCompleted evento.
Metodo pubblicoReportProgress(Int32)Generato ProgressChanged evento.
Metodo pubblicoReportProgress(Int32, Object)Generato ProgressChanged evento.
Metodo pubblicoRunWorkerAsync()Avvia l'esecuzione di un'operazione in background.
Metodo pubblicoRunWorkerAsync(Object)Avvia l'esecuzione di un'operazione in background.
Metodo pubblicoToStringRestituisce un oggetto String contenere il nome Component, se presente. Questo metodo non deve essere sottoposto a override. (Ereditato da Component)
In alto

  NomeDescrizione
Evento pubblicoDisposedSi verifica quando il componente viene eliminato da una chiamata a Dispose metodo. (Ereditato da Component)
Evento pubblicoDoWorksi verifica quando RunWorkerAsync viene chiamato.
Evento pubblicoProgressChangedsi verifica quando ReportProgress viene chiamato.
Evento pubblicoRunWorkerCompletedSi verifica quando l'operazione in background ha completato, è stato annullato, o è stata generata un'eccezione.
In alto

BackgroundWorker la classe consente di eseguire un'operazione su un thread dedicato separato. Operazioni che richiedono molto tempo come download e transazioni di database possono causare l'interfaccia utente (UI) a essere visualizzato come se non risponda quando sono in esecuzione. Quando si un'interfaccia utente reattiva e si affrontato ai lunghi ritardi associati a tali operazioni, BackgroundWorker la classe fornisce una soluzione pratica.

Per eseguire un'operazione lunga ed elaborata in background, creare un oggetto BackgroundWorker e possono ascoltare gli eventi che segnalano lo stato di avanzamento dell'operazione e segnali quando l'operazione viene completata. È possibile creare BackgroundWorker a livello di codice oppure è possibile trascinarlo nel form da componenti scheda di Casella degli strumenti. Se si creano BackgroundWorker in Progettazione Windows Form, verrà visualizzato nella barra dei componenti e le relative proprietà visualizzate nella Finestra Proprietà.

Per impostare un'operazione in background, aggiungere un gestore eventi per DoWork evento. Chiamare l'operazione dispendiosa in termini di tempo nel gestore eventi. Per avviare l'operazione, chiamata RunWorkerAsync. Per ricevere notifiche degli aggiornamenti di stato, gestire ProgressChanged evento. Per ricevere una notifica quando l'operazione viene completata, gestire RunWorkerCompleted evento.

NotaNota

È necessario prestare attenzione a non modificare oggetti dell'interfaccia utente in DoWork gestore eventi. Al contrario, passare all'interfaccia utente con ProgressChanged e RunWorkerCompleted eventi.

BackgroundWorker gli eventi non viene eseguito il marshalling oltre AppDomain limiti. Non utilizzare un oggetto BackgroundWorker componente per eseguire operazioni multithread in più AppDomain.

se l'operazione in background richiede un parametro, chiamare RunWorkerAsync con il parametro. In DoWork gestore eventi, è possibile estrarre il parametro da DoWorkEventArgs::Argument proprietà.

per ulteriori informazioni su BackgroundWorker, vedere Procedura: eseguire un'operazione in background.

NotaNota

L'attributo HostProtectionAttribute applicato a questo tipo o membro dispone del seguente Resources valore della proprietà: SharedState. L'oggetto HostProtectionAttribute non influisce sulle applicazioni desktop, che in genere vengono avviate facendo doppio clic sull'icona, digitando un comando oppure immettendo un URL in un browser. Per ulteriori informazioni, vedere la classe HostProtectionAttribute o programmazione per SQL Server e attributi di protezione host.

Nell'esempio di codice vengono illustrate le nozioni fondamentali sui BackgroundWorker classe per eseguire un'operazione lunga ed elaborata 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 oggetto Label controllo denominato resultLabel e aggiungere due Button controlli denominati startAsyncButton e cancelAsyncButton. creare Click gestori eventi per entrambi i pulsanti. Da componenti la scheda della casella degli strumenti, aggiungere un oggetto BackgroundWorker componente denominato backgroundWorker1. creare DoWork, ProgressChangede RunWorkerCompleted gestori eventi per 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.

Nell'esempio di codice seguente viene illustrato l'utilizzo di BackgroundWorker classe per eseguire un'operazione lunga ed elaborata in modo asincrono. Nella figura seguente viene illustrato un esempio dell'output.

Esempio di BackgroundWorker con calcolo della sequenza di Fibonacci

L'operazione consente di calcolare l'numero di Fibonacci selezionato, i rapporti stato aggiornato durante il calcolo continuerà e consente di un calcolo in attesa di essere annullato.


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


.NET Framework

Supportato in: 4.5, 4, 3.5, 3.0, 2.0

.NET Framework Client Profile

Supportato in: 4, 3.5 SP1

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

Qualsiasi membro pubblico static (Shared in Visual Basic) di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Aggiunte alla community

AGGIUNGI
Mostra:
© 2014 Microsoft