Suche…


Syntax

  • bgWorker.CancellationPending //returns whether the bgWorker was cancelled during its operation

  • bgWorker.IsBusy //returns true if the bgWorker is in the middle of an operation

  • bgWorker.ReportProgress(int x) //Reports a change in progress. Raises the "ProgressChanged" event

  • bgWorker.RunWorkerAsync() //Starts the BackgroundWorker by raising the "DoWork" event

  • bgWorker.CancelAsync() //instructs the BackgroundWorker to stop after the completion of a task.

Bemerkungen

Durch das Ausführen lang andauernder Vorgänge innerhalb des UI-Threads kann Ihre Anwendung nicht mehr reagieren und dem Benutzer angezeigt werden, dass sie nicht mehr funktioniert. Es wird bevorzugt, dass diese Aufgaben in einem Hintergrundthread ausgeführt werden. Nach dem Abschluss kann die Benutzeroberfläche aktualisiert werden.

Wenn Sie während des Vorgangs des BackgroundWorker Änderungen an der Benutzeroberfläche vornehmen möchten , müssen Sie die Änderungen am Benutzeroberflächenthread aufrufen, normalerweise mithilfe der Methode Control.Invoke für das Steuerelement, das Sie aktualisieren. Andernfalls wird Ihr Programm eine Ausnahme auslösen.

Der BackgroundWorker wird normalerweise nur in Windows Forms-Anwendungen verwendet. In WPF-Anwendungen werden Aufgaben dazu verwendet, Arbeit auf Hintergrundthreads abzuladen (möglicherweise in Kombination mit Async / await ). Marshalling-Aktualisierungen für den UI-Thread werden normalerweise automatisch ausgeführt, wenn die zu aktualisierende Eigenschaft INotifyPropertyChanged implementiert, oder manuell mithilfe des Dispatcher des UI-Thread.

Event-Handler einem BackgroundWorker zuordnen

Nachdem die Instanz von BackgroundWorker deklariert wurde, müssen Eigenschaften und Ereignishandler für die durchgeführten Aufgaben angegeben werden.

    /* This is the backgroundworker's "DoWork" event handler. This 
       method is what will contain all the work you 
       wish to have your program perform without blocking the UI. */

    bgWorker.DoWork += bgWorker_DoWork;


    /*This is how the DoWork event method signature looks like:*/
    private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        // Work to be done here   
        // ...
        // To get a reference to the current Backgroundworker:
        BackgroundWorker worker = sender as BackgroundWorker;
        // The reference to the BackgroundWorker is often used to report progress
        worker.ReportProgress(...);
    }

    /*This is the method that will be run once the BackgroundWorker has completed its tasks */

    bgWorker.RunWorkerCompleted += bgWorker_CompletedWork;

    /*This is how the RunWorkerCompletedEvent event method signature looks like:*/
    private void bgWorker_CompletedWork(object sender, RunWorkerCompletedEventArgs e)
    {
        // Things to be done after the backgroundworker has finished
    }

   /* When you wish to have something occur when a change in progress 
     occurs, (like the completion of a specific task) the "ProgressChanged" 
     event handler is used. Note that ProgressChanged events may be invoked
     by calls to bgWorker.ReportProgress(...) only if bgWorker.WorkerReportsProgress
     is set to true.  */

     bgWorker.ProgressChanged += bgWorker_ProgressChanged;

    /*This is how the ProgressChanged event method signature looks like:*/
    private void bgWorker_ProgressChanged(object sender, ProgressChangedEventArgs e)
    {
        // Things to be done when a progress change has been reported

        /* The ProgressChangedEventArgs gives access to a percentage,
         allowing for easy reporting of how far along a process is*/
        int progress = e.ProgressPercentage;
    }

Eigenschaften einem BackgroundWorker zuweisen

Dadurch kann der BackgroundWorker zwischen Aufgaben abgebrochen werden

bgWorker.WorkerSupportsCancellation = true;

Dadurch kann der Arbeiter den Fortschritt zwischen dem Abschluss der Aufgaben ...

bgWorker.WorkerReportsProgress = true;

//this must also be used in conjunction with the ProgressChanged event

Erstellen einer neuen BackgroundWorker-Instanz

Ein BackgroundWorker wird normalerweise zum Ausführen von Aufgaben verwendet, die manchmal zeitraubend sind, ohne den UI-Thread zu blockieren.

// BackgroundWorker is part of the ComponentModel namespace.
using System.ComponentModel;

namespace BGWorkerExample 
{
     public partial class ExampleForm : Form 
     {

      // the following creates an instance of the BackgroundWorker named "bgWorker"
      BackgroundWorker bgWorker = new BackgroundWorker();

      public ExampleForm() { ...

Verwenden eines BackgroundWorker zum Abschließen einer Aufgabe.

Das folgende Beispiel veranschaulicht die Verwendung eines BackgroundWorker zum Aktualisieren einer WinForms-Fortschrittsleiste. Der backgroundWorker aktualisiert den Wert der Fortschrittsleiste, ohne den UI-Thread zu blockieren. Dadurch wird eine reaktive UI angezeigt, während die Arbeit im Hintergrund ausgeführt wird.

namespace BgWorkerExample
{
    public partial class Form1 : Form
{

    //a new instance of a backgroundWorker is created.
    BackgroundWorker bgWorker = new BackgroundWorker();
    
    public Form1()
    {
        InitializeComponent();

        prgProgressBar.Step = 1;

        //this assigns event handlers for the backgroundWorker
        bgWorker.DoWork += bgWorker_DoWork;
        bgWorker.RunWorkerCompleted += bgWorker_WorkComplete;

        //tell the backgroundWorker to raise the "DoWork" event, thus starting it.
        //Check to make sure the background worker is not already running.
        if(!bgWorker.IsBusy)
            bgWorker.RunWorkerAsync();
        
    }

    private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
    {
        //this is the method that the backgroundworker will perform on in the background thread.
        /* One thing to note! A try catch is not necessary as any exceptions will terminate the backgroundWorker and report 
          the error to the "RunWorkerCompleted" event */
        CountToY();    
    }

    private void bgWorker_WorkComplete(object sender, RunWorkerCompletedEventArgs e)
    {
        //e.Error will contain any exceptions caught by the backgroundWorker
        if (e.Error != null)
        {
            MessageBox.Show(e.Error.Message);
        }
        else
        {
            MessageBox.Show("Task Complete!");
            prgProgressBar.Value = 0;
        }
    }

    // example method to perform a "long" running task.
    private void CountToY()
    {
        int x = 0;

        int maxProgress = 100;
        prgProgressBar.Maximum = maxProgress;
        

        while (x < maxProgress)
        {
            System.Threading.Thread.Sleep(50);
            Invoke(new Action(() => { prgProgressBar.PerformStep(); }));
            x += 1;
        }
    }


}

Das Ergebnis ist folgendes ...

Geben Sie hier die Bildbeschreibung ein Geben Sie hier die Bildbeschreibung ein



Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow