Anleitung: Ausführen eines Vorgangs im Hintergrund

2025-05-07

Wenn Sie einen Vorgang haben, der lange dauert, bis der Vorgang abgeschlossen ist und Sie keine Verzögerungen in der Benutzeroberfläche verursachen möchten, können Sie die BackgroundWorker Klasse verwenden, um den Vorgang in einem anderen Thread auszuführen.

Eine vollständige Auflistung des codes, der in diesem Beispiel verwendet wird, finden Sie unter How to: Run an Operation in the Background.

Ausführen eines Vorgangs im Hintergrund

Wenn Ihr Formular im Windows Forms-Designer in Visual Studio aktiv ist, ziehen Sie zwei Button Steuerelemente aus der Toolbox in das Formular, und legen Sie dann die Name Schaltflächen und Text Eigenschaften entsprechend der folgenden Tabelle fest.

Schaltfläche Name Text

button1 startBtn Starten

button2 cancelBtn Abbrechen
Öffnen Sie die Toolbox, klicken Sie auf die Registerkarte "Komponenten ", und ziehen Sie die BackgroundWorker Komponente dann auf das Formular.

Die backgroundWorker1 Komponente wird in der Komponentenablage angezeigt.
Legen Sie im Fenster Eigenschaften die eigenschaft WorkerSupportsCancellation auf truefest.
Klicken Sie im Eigenschaftenfenster auf die Schaltfläche " Ereignisse ", und doppelklicken Sie dann auf die DoWork Ereignisse RunWorkerCompleted , um Ereignishandler zu erstellen.
Fügen Sie Ihren zeitaufwendigen Code in den DoWork Ereignishandler ein.
Extrahieren Sie alle Parameter, die für den Vorgang erforderlich sind, aus der Argument Eigenschaft des DoWorkEventArgs Parameters.

Schaltfläche	Name	Text
`button1`	`startBtn`	Starten
`button2`	`cancelBtn`	Abbrechen

Weisen Sie das Ergebnis der Berechnung der Eigenschaft Result des DoWorkEventArgs zu.

Dies ist für den RunWorkerCompleted Ereignishandler verfügbar.

private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
    // Do not access the form's BackgroundWorker reference directly.
    // Instead, use the reference provided by the sender parameter.
    BackgroundWorker bw = sender as BackgroundWorker;

    // Extract the argument.
    int arg = (int)e.Argument;

    // Start the time-consuming operation.
    e.Result = TimeConsumingOperation(bw, arg);

    // If the operation was canceled by the user,
    // set the DoWorkEventArgs.Cancel property to true.
    if (bw.CancellationPending)
    {
        e.Cancel = true;
    }
}

Private Sub backgroundWorker1_DoWork( _
sender As Object, e As DoWorkEventArgs) _
Handles backgroundWorker1.DoWork

   ' Do not access the form's BackgroundWorker reference directly.
   ' Instead, use the reference provided by the sender parameter.
   Dim bw As BackgroundWorker = CType( sender, BackgroundWorker )
   
   ' Extract the argument.
   Dim arg As Integer = Fix(e.Argument)
   
   ' Start the time-consuming operation.
   e.Result = TimeConsumingOperation(bw, arg)
   
   ' If the operation was canceled by the user, 
   ' set the DoWorkEventArgs.Cancel property to true.
   If bw.CancellationPending Then
      e.Cancel = True
   End If

End Sub

Fügen Sie Code zum Abrufen des Ergebnisses des Vorgangs im RunWorkerCompleted Ereignishandler ein.

// This event handler demonstrates how to interpret
// the outcome of the asynchronous operation implemented
// in the DoWork event handler.
private void backgroundWorker1_RunWorkerCompleted(
    object sender,
    RunWorkerCompletedEventArgs e)
{
    if (e.Cancelled)
    {
        // The user canceled the operation.
        MessageBox.Show("Operation was canceled");
    }
    else if (e.Error != null)
    {
        // There was an error during the operation.
        string msg = String.Format("An error occurred: {0}", e.Error.Message);
        MessageBox.Show(msg);
    }
    else
    {
        // The operation completed normally.
        string msg = String.Format("Result = {0}", e.Result);
        MessageBox.Show(msg);
    }
}

' This event handler demonstrates how to interpret 
' the outcome of the asynchronous operation implemented
' in the DoWork event handler.
Private Sub backgroundWorker1_RunWorkerCompleted( _
sender As Object, e As RunWorkerCompletedEventArgs) _
Handles backgroundWorker1.RunWorkerCompleted

   If e.Cancelled Then
      ' The user canceled the operation.
      MessageBox.Show("Operation was canceled")
   ElseIf (e.Error IsNot Nothing) Then
      ' There was an error during the operation.
      Dim msg As String = String.Format("An error occurred: {0}", e.Error.Message)
      MessageBox.Show(msg)
   Else
      ' The operation completed normally.
      Dim msg As String = String.Format("Result = {0}", e.Result)
      MessageBox.Show(msg)
   End If
End Sub

Implementieren Sie die TimeConsumingOperation-Methode.

// This method models an operation that may take a long time
// to run. It can be cancelled, it can raise an exception,
// or it can exit normally and return a result. These outcomes
// are chosen randomly.
private int TimeConsumingOperation(
    BackgroundWorker bw,
    int sleepPeriod )
{
    int result = 0;

    Random rand = new Random();

    while (!bw.CancellationPending)
    {
        bool exit = false;

        switch (rand.Next(3))
        {
            // Raise an exception.
            case 0:
            {
                throw new Exception("An error condition occurred.");
                break;
            }

            // Sleep for the number of milliseconds
            // specified by the sleepPeriod parameter.
            case 1:
            {
                Thread.Sleep(sleepPeriod);
                break;
            }

            // Exit and return normally.
            case 2:
            {
                result = 23;
                exit = true;
                break;
            }

            default:
            {
                break;
            }
        }

        if( exit )
        {
            break;
        }
    }

    return result;
}

' This method models an operation that may take a long time 
' to run. It can be cancelled, it can raise an exception,
' or it can exit normally and return a result. These outcomes
' are chosen randomly.
Private Function TimeConsumingOperation( _
bw As BackgroundWorker, _
sleepPeriod As Integer) As Integer

   Dim result As Integer = 0
   
   Dim rand As New Random()
   
     While Not bw.CancellationPending
         Dim [exit] As Boolean = False

         Select Case rand.Next(3)
             ' Raise an exception.
             Case 0
                 Throw New Exception("An error condition occurred.")
                 Exit While

                 ' Sleep for the number of milliseconds
                 ' specified by the sleepPeriod parameter.
             Case 1
                 Thread.Sleep(sleepPeriod)
                 Exit While

                 ' Exit and return normally.
             Case 2
                 result = 23
                 [exit] = True
                 Exit While

             Case Else
                 Exit While
         End Select

         If [exit] Then
             Exit While
         End If
     End While
   
   Return result
End Function

Doppelklicken Sie startButton im Windows Forms-Designer, um den Click Ereignishandler zu erstellen.

Rufen Sie die RunWorkerAsync Methode im Click Ereignishandler für startButton.

private void startBtn_Click(object sender, EventArgs e)
{
    this.backgroundWorker1.RunWorkerAsync(2000);
}

Private Sub startButton_Click(ByVal sender As Object, ByVal e As EventArgs) Handles startBtn.Click
    Me.backgroundWorker1.RunWorkerAsync(2000)
End Sub

Doppelklicken Sie cancelButton im Windows Forms-Designer, um den Click Ereignishandler zu erstellen.

Rufen Sie die CancelAsync Methode im Click Ereignishandler für cancelButton.

private void cancelBtn_Click(object sender, EventArgs e)
{
    this.backgroundWorker1.CancelAsync();
}

Private Sub cancelButton_Click(ByVal sender As Object, ByVal e As EventArgs) Handles cancelBtn.Click
    Me.backgroundWorker1.CancelAsync()
End Sub

Importieren Sie oben in der Datei die Namespaces "System.ComponentModel" und "System.Threading".

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

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

Drücken Sie F6 , um die Lösung zu erstellen, und drücken Sie dann STRG+F5 , um die Anwendung außerhalb des Debuggers auszuführen.

Hinweis

Wenn Sie F5 drücken, um die Anwendung unter dem Debugger auszuführen, wird die in der TimeConsumingOperation Methode ausgelöste Ausnahme vom Debugger abgefangen und angezeigt. Wenn Sie die Anwendung außerhalb des Debuggers ausführen, behandelt die BackgroundWorker Ausnahme und speichert sie im Eigenschaftsfeld Error der RunWorkerCompletedEventArgs.
Klicken Sie auf die Schaltfläche "Start ", um einen asynchronen Vorgang auszuführen, und klicken Sie dann auf die Schaltfläche "Abbrechen ", um einen ausgeführten asynchronen Vorgang zu beenden.

Das Ergebnis der einzelnen Vorgänge wird in einer MessageBox.

Nächste Schritte

Implementieren Sie ein Formular, das den Fortschritt meldet, während ein asynchroner Vorgang fortgesetzt wird. Weitere Informationen finden Sie unter Vorgehensweise: Implementieren eines Formulars, das einen Hintergrundvorgang verwendet.
Implementieren Sie eine Klasse, die das asynchrone Muster für Komponenten unterstützt. Weitere Informationen finden Sie unter Implementieren des ereignisbasierten asynchronen Musters.

Freigeben über

Anleitung: Ausführen eines Vorgangs im Hintergrund

Ausführen eines Vorgangs im Hintergrund

Nächste Schritte

Siehe auch

Feedback

Zusätzliche Ressourcen