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 Class BackgroundWorker
	Inherits 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 tutte le informazioni rilevanti 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.

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 backgroundWorker1.IsBusy <> True 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 = True 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 = True) 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 = True 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

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.

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.Drawing
Imports System.Threading
Imports System.Windows.Forms

Public Class FibonacciForm
    Inherits System.Windows.Forms.Form

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

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


    Public Sub New()
        InitializeComponent()
    End Sub 'NewNew

    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.
        Me.numericUpDown1.Enabled = False

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

        ' Enable the Cancel button while 
        ' the asynchronous operation runs.
        Me.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.
        Me.backgroundWorker1.CancelAsync()

        ' Disable the Cancel button.
        cancelAsyncButton.Enabled = False

    End Sub 'cancelAsyncButton_Click

    ' 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 'backgroundWorker1_DoWork

    ' 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.
        Me.numericUpDown1.Enabled = True

        ' Enable the Start button.
        startAsyncButton.Enabled = True

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

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

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

    End Sub 'InitializeComponent

    <STAThread()> _
    Shared Sub Main()
        Application.Run(New FibonacciForm)
    End Sub 'Main
End Class '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: