Dieser Artikel wurde maschinell übersetzt. Wenn Sie die englische Version des Artikels anzeigen möchten, aktivieren Sie das Kontrollkästchen Englisch. Sie können den englischen Text auch in einem Popupfenster anzeigen, indem Sie den Mauszeiger über den Text bewegen.
Übersetzung
Englisch

BackgroundWorker-Klasse

 

Veröffentlicht: Oktober 2016

Führt einen Vorgang im separaten Thread aus.

Namespace:   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 : Component

NameBeschreibung
System_CAPS_pubmethodBackgroundWorker()

Initialisiert eine neue Instanz der BackgroundWorker-Klasse.

NameBeschreibung
System_CAPS_pubpropertyCancellationPending

Ruft einen Wert, der angibt, ob die Anwendung den Abbruch eines Hintergrundvorgangs angefordert hat.

System_CAPS_protpropertyCanRaiseEvents

Ruft einen Wert, der angibt, ob die Komponente ein Ereignis auslösen kann.(Geerbt von „Component“.)

System_CAPS_pubpropertyContainer

Ruft die IContainer enthält die Component.(Geerbt von „Component“.)

System_CAPS_protpropertyDesignMode

Ruft einen Wert, der angibt, ob die Component befindet sich derzeit im Entwurfsmodus befindet.(Geerbt von „Component“.)

System_CAPS_protpropertyEvents

Ruft die Liste der Ereignishandler, die mit dieser verknüpft sind Component.(Geerbt von „Component“.)

System_CAPS_pubpropertyIsBusy

Ruft einen Wert, der angibt, ob der BackgroundWorker einen asynchronen Vorgang ausgeführt wird.

System_CAPS_pubpropertySite

Ruft ab oder legt die ISite von der Component.(Geerbt von „Component“.)

System_CAPS_pubpropertyWorkerReportsProgress

Ruft ab oder legt einen Wert, der angibt, ob die BackgroundWorker Fortschritt melden können.

System_CAPS_pubpropertyWorkerSupportsCancellation

Ruft ab oder legt einen Wert, der angibt, ob die BackgroundWorker asynchrone Abbrüche unterstützt.

NameBeschreibung
System_CAPS_pubmethodCancelAsync()

Fordert das Abbrechen eines anstehenden Hintergrundvorgangs.

System_CAPS_pubmethodCreateObjRef(Type)

Erstellt ein Objekt, das alle relevanten Informationen, die zum Generieren eines Proxys für die Kommunikation mit einem Remoteobjekt verwendet die enthält.(Geerbt von „MarshalByRefObject“.)

System_CAPS_pubmethodDispose()

Gibt alle vom Component verwendeten Ressourcen frei.(Geerbt von „Component“.)

System_CAPS_protmethodDispose(Boolean)

Gibt die von Component verwendeten nicht verwalteten Ressourcen und optional die verwalteten Ressourcen frei.(Geerbt von „Component“.)

System_CAPS_pubmethodEquals(Object)

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.(Geerbt von „Object“.)

System_CAPS_protmethodFinalize()

Gibt nicht verwaltete Ressourcen frei und führt andere Bereinigungsvorgänge durch, bevor die Component durch die Garbage Collection wieder zugänglich gemacht wird.(Geerbt von „Component“.)

System_CAPS_pubmethodGetHashCode()

Fungiert als die Standardhashfunktion.(Geerbt von „Object“.)

System_CAPS_pubmethodGetLifetimeService()

Ruft das Dienstobjekt für aktuellen Lebensdauer, das steuert, die lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodGetService(Type)

Gibt ein Objekt zurück, das einen von der Component oder von deren Container bereitgestellten Dienst darstellt.(Geerbt von „Component“.)

System_CAPS_pubmethodGetType()

Ruft den Type der aktuellen Instanz ab.(Geerbt von „Object“.)

System_CAPS_pubmethodInitializeLifetimeService()

Ruft ein Lebensdauerdienstobjekt zur Steuerung der Lebensdauerrichtlinie für diese Instanz ab.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodMemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.(Geerbt von „Object“.)

System_CAPS_protmethodMemberwiseClone(Boolean)

Erstellt eine flache Kopie des aktuellen MarshalByRefObject Objekt.(Geerbt von „MarshalByRefObject“.)

System_CAPS_protmethodOnDoWork(DoWorkEventArgs)

Löst das DoWork-Ereignis aus.

System_CAPS_protmethodOnProgressChanged(ProgressChangedEventArgs)

Löst das ProgressChanged-Ereignis aus.

System_CAPS_protmethodOnRunWorkerCompleted(RunWorkerCompletedEventArgs)

Löst das RunWorkerCompleted-Ereignis aus.

System_CAPS_pubmethodReportProgress(Int32)

Löst das ProgressChanged-Ereignis aus.

System_CAPS_pubmethodReportProgress(Int32, Object)

Löst das ProgressChanged-Ereignis aus.

System_CAPS_pubmethodRunWorkerAsync()

Startet die Ausführung eines Hintergrundvorgangs.

System_CAPS_pubmethodRunWorkerAsync(Object)

Startet die Ausführung eines Hintergrundvorgangs.

System_CAPS_pubmethodToString()

Gibt eine String mit dem Namen der Component, sofern vorhanden. Diese Methode darf nicht überschrieben werden.(Geerbt von „Component“.)

NameBeschreibung
System_CAPS_pubeventDisposed

Tritt auf, wenn die Komponente, durch einen Aufruf freigegeben wird der Dispose Methode.(Geerbt von „Component“.)

System_CAPS_pubeventDoWork

Tritt auf, wenn RunWorkerAsync aufgerufen wird.

System_CAPS_pubeventProgressChanged

Tritt auf, wenn ReportProgress aufgerufen wird.

System_CAPS_pubeventRunWorkerCompleted

Tritt auf, wenn der Hintergrundvorgang abgeschlossen, abgebrochen wurde oder eine Ausnahme ausgelöst hat.

Die BackgroundWorker -Klasse können Sie eine Operation auf einem separaten, dedizierten Thread ausführen. Zeitaufwändige Operationen wie Downloads und Datenbanktransaktionen können dazu führen, dass die Benutzeroberfläche (UI), scheint es nicht mehr reagiert, während diese ausgeführt werden. Wenn Sie eine reaktionsfähige Benutzeroberfläche und bei solchen Operationen lange Verzögerungen vermeiden der BackgroundWorker -Klasse bietet eine praktische Lösung.

Um einen zeitaufwändigen Vorgang im Hintergrund auszuführen, Erstellen einer BackgroundWorker und überwachen Sie Ereignisse, die den Fortschritt der Operation und Signal melden, wenn der Vorgang abgeschlossen ist. Können die BackgroundWorker programmgesteuert oder aus in ein Formular ziehen die Komponenten auf der Registerkarte der Toolbox. Bei der Erstellung der BackgroundWorker in Windows Forms-Designer in der Komponentenleiste angezeigt, und seine Eigenschaften werden im Eigenschaftenfenster angezeigt.

Um eine Hintergrundoperation einzurichten, fügen Sie einen Ereignishandler für das DoWork Ereignis hinzu. Rufen Sie den zeitaufwändigen Vorgang in diesem Ereignishandler. Um den Vorgang zu starten, rufen RunWorkerAsync. Zum Empfangen von Benachrichtigungen Statusupdates behandelt die ProgressChanged Ereignis. Um eine Benachrichtigung erhalten, wenn der Vorgang abgeschlossen ist, behandelt der RunWorkerCompleted Ereignis.

System_CAPS_noteHinweis

Sie müssen darauf achten, dass keine Objekte der Benutzeroberfläche in Bearbeitung werden Ihre DoWork -Ereignishandler. Stattdessen zum Kommunizieren mit der Benutzeroberfläche der ProgressChanged und RunWorkerCompleted Ereignisse.

BackgroundWorker -Ereignisse werden nicht über gemarshallt AppDomain Grenzen. Verwenden Sie keine BackgroundWorker auszuführenden Vorgänge mit mehreren Threads in mehr als einer Komponente AppDomain.

Wenn der Hintergrundvorgang einen Parameter erfordert, rufen Sie RunWorkerAsync mit dem Parameter. In der DoWork -Ereignishandler können Sie den Parameter aus Extrahieren der DoWorkEventArgs.Argument Eigenschaft.

Weitere Informationen zu BackgroundWorker finden Sie unter Gewusst wie: Ausführen eines Vorgangs im Hintergrund.

Das folgende Codebeispiel veranschaulicht die Grundlagen von der BackgroundWorker -Klasse für einen zeitaufwändigen Vorgang asynchron ausgeführt. Die folgende Abbildung zeigt ein Beispiel der Ausgabe.

Einfaches Beispiel für BackgroundWorker

Um diesen Code zu testen, erstellen Sie eine Windows Forms-Anwendung. Hinzufügen einer Label -Steuerelement namens resultLabel und Hinzufügen von zwei Button -Steuerelemente namens startAsyncButton und cancelAsyncButton. Erstellen Sie Click -Ereignishandler für beide Schaltflächen. Aus der Komponenten Registerkarte der Toolbox hinzufügen einer BackgroundWorker Komponente namens backgroundWorker1. Erstellen Sie DoWork, ProgressChanged, und RunWorkerCompleted -Ereignishandler für die BackgroundWorker. Ersetzen Sie im Code für das Formular den vorhandenen Code durch den folgenden Code ein.

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

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

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

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

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

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

Das folgende Codebeispiel veranschaulicht die Verwendung der BackgroundWorker -Klasse für einen zeitaufwändigen Vorgang asynchron ausgeführt. Die folgende Abbildung zeigt ein Beispiel der Ausgabe.

Fibonacci-Beispiel für BackgroundWorker

Der Vorgang der ausgewählten Fibonacci-Zahl berechnet, meldet Statusupdates während der Berechnung durchgeführt wird und ermöglicht eine ausstehende Berechnung abgebrochen werden soll.

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

namespace BackgroundWorkerExample
{	
    public class FibonacciForm : System.Windows.Forms.Form
    {	
        private int numberToCompute = 0;
        private int highestPercentageReached = 0;

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

        public FibonacciForm()
        {	
            InitializeComponent();

            InitializeBackgroundWorker();
        }

        // Set up the BackgroundWorker object by 
        // attaching event handlers. 
        private void InitializeBackgroundWorker()
        {
            backgroundWorker1.DoWork += 
                new DoWorkEventHandler(backgroundWorker1_DoWork);
            backgroundWorker1.RunWorkerCompleted += 
                new RunWorkerCompletedEventHandler(
            backgroundWorker1_RunWorkerCompleted);
            backgroundWorker1.ProgressChanged += 
                new ProgressChangedEventHandler(
            backgroundWorker1_ProgressChanged);
        }

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

        private 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.
        private 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.
        private 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.
            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.
        private 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 new ArgumentException(
                    "value must be >= 0 and <= 91", "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
            {   
                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;
        }


		#region Windows Form Designer generated code

        private void InitializeComponent()
        {
            this.numericUpDown1 = new System.Windows.Forms.NumericUpDown();
            this.startAsyncButton = new System.Windows.Forms.Button();
            this.cancelAsyncButton = new System.Windows.Forms.Button();
            this.resultLabel = new System.Windows.Forms.Label();
            this.progressBar1 = new System.Windows.Forms.ProgressBar();
            this.backgroundWorker1 = new System.ComponentModel.BackgroundWorker();
            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).BeginInit();
            this.SuspendLayout();
            // 
            // numericUpDown1
            // 
            this.numericUpDown1.Location = new System.Drawing.Point(16, 16);
            this.numericUpDown1.Maximum = new System.Decimal(new int[] {
            91,
            0,
            0,
            0});
            this.numericUpDown1.Minimum = new System.Decimal(new int[] {
            1,
            0,
            0,
            0});
            this.numericUpDown1.Name = "numericUpDown1";
            this.numericUpDown1.Size = new System.Drawing.Size(80, 20);
            this.numericUpDown1.TabIndex = 0;
            this.numericUpDown1.Value = new System.Decimal(new int[] {
            1,
            0,
            0,
            0});
            // 
            // startAsyncButton
            // 
            this.startAsyncButton.Location = new System.Drawing.Point(16, 72);
            this.startAsyncButton.Name = "startAsyncButton";
            this.startAsyncButton.Size = new System.Drawing.Size(120, 23);
            this.startAsyncButton.TabIndex = 1;
            this.startAsyncButton.Text = "Start Async";
            this.startAsyncButton.Click += new System.EventHandler(this.startAsyncButton_Click);
            // 
            // cancelAsyncButton
            // 
            this.cancelAsyncButton.Enabled = false;
            this.cancelAsyncButton.Location = new System.Drawing.Point(153, 72);
            this.cancelAsyncButton.Name = "cancelAsyncButton";
            this.cancelAsyncButton.Size = new System.Drawing.Size(119, 23);
            this.cancelAsyncButton.TabIndex = 2;
            this.cancelAsyncButton.Text = "Cancel Async";
            this.cancelAsyncButton.Click += new System.EventHandler(this.cancelAsyncButton_Click);
            // 
            // resultLabel
            // 
            this.resultLabel.BorderStyle = System.Windows.Forms.BorderStyle.Fixed3D;
            this.resultLabel.Location = new System.Drawing.Point(112, 16);
            this.resultLabel.Name = "resultLabel";
            this.resultLabel.Size = new 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 = new System.Drawing.Point(18, 48);
            this.progressBar1.Name = "progressBar1";
            this.progressBar1.Size = new 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 = new 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";
            ((System.ComponentModel.ISupportInitialize)(this.numericUpDown1)).EndInit();
            this.ResumeLayout(false);

        }
		#endregion

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

Universelle Windows-Plattform
Verfügbar seit 10
.NET Framework
Verfügbar seit 2.0
Silverlight
Verfügbar seit 2.0
Windows Phone Silverlight
Verfügbar seit 7.0

Alle öffentlichen statischen Member ( Shared in Visual Basic) dieses Typs sind threadsicher. Die Threadsicherheit für Instanzmember ist nicht garantiert.

Zurück zum Anfang
Anzeigen: