Richtiger Weg, einen BackGroundWorker zu entsorgen

Question

Wäre das eine gute Möglichkeit, einen BackGroundWorker zu entsorgen? Ich bin mir nicht sicher, ob es notwendig ist, die Ereignisse vor dem Aufruf von .Dispose() zu entfernen. Auch Aufruf von .Dispose() innerhalb des RunWorkerCompleted-Delegat in Ordnung zu tun?

public void RunProcessAsync(DateTime dumpDate) 
{ 
    BackgroundWorker worker = new BackgroundWorker(); 
    worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); 
    worker.DoWork += new DoWorkEventHandler(worker_DoWork); 
    worker.RunWorkerAsync(dumpDate); 
} 

void worker_DoWork(object sender, DoWorkEventArgs e) 
{ 
    // Do Work here 
} 

void worker_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e) 
{ 
    BackgroundWorker worker = sender as BackgroundWorker; 
    worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); 
    worker.DoWork -= new DoWorkEventHandler(worker_DoWork); 
    worker.Dispose(); 
} 

Answer 1

BackgroundWorker leitet sich von Component ab. Component implementiert die IDisposable-Schnittstelle. Dies wiederum bewirkt, dass BackgroundWorker die Dispose() -Methode erbt.

Das Ableiten von Component ist eine Annehmlichkeit für Windows Forms-Programmierer, sie können eine BGW aus der Toolbox auf ein Formular löschen. Komponenten haben im Allgemeinen etwas zu veräußern. Der Windows Forms-Designer erledigt dies automatisch. Suchen Sie in der Datei Designer.cs nach einem Formular für das Feld "Komponenten". Die automatisch generierte Dispose() -Methode ruft die Dispose() -Methode für alle Komponenten auf.

Allerdings hat BackgroundWorker eigentlich kein Mitglied, das entsorgt werden muss. Es überschreibt Dispose() nicht. Die Basisimplementierung, Component.Dispose(), stellt nur sicher, dass die Komponente aus der Sammlung "components" entfernt wird. Und hebe das Disposed-Ereignis auf. Verfügt aber ansonsten nichts.

Lange Rede, kurzer Sinn: Wenn Sie eine BGW auf ein Formular fallen lassen, dann wird alles automatisch erledigt, Sie müssen nicht helfen. Wenn Sie es nicht in ein Formular eingefügt haben, ist es kein Element in einer Komponentensammlung und es muss nichts getan werden.

Sie müssen nicht Dispose() aufrufen.

Answer 2

Ja, das scheint richtig. Natürlich werden Einwegobjekte besser mit using Blöcken behandelt, aber Sie haben diese Option hier nicht.

Normalerweise erstelle ich meine Hintergrund-Handler mit Formular-Lebenszeiten, wiederverwenden sie und lassen Sie den Designer-Code Umgang mit Formular schließen. Weniger zum Nachdenken.

Answer 3

Wenn es auf einem „WinForms“ Form ist der Behälter lassen sich darum kümmern (siehe die erzeugte Dispose Code in der Datei Form.Designer.xyz)

In der Praxis habe ich festgestellt, dass Sie ein erstellen müssen können Instanz des Containers und fügen Sie den Worker (oder einen anderen Companent) hinzu, wenn jemand einen offizielleren Weg kennt, dies zu tun!

PK :-)

public partial class Form1 : Form 
{ 
    public Form1() 
    { 
     InitializeComponent(); 

     // watch the disposed event.... 
     backgroundWorker1.Disposed += new EventHandler(backgroundWorker1_Disposed); 

     // try with and without the following lines 
     components = new Container(); 
     components.Add(backgroundWorker1); 
    } 

    void backgroundWorker1_Disposed(object sender, EventArgs e) 
    { 
     Debug.WriteLine("backgroundWorker1_Disposed"); 
    } 

//... from the Designer.xyz file ... 

    /// <summary> 
    /// Clean up any resources being used. 
    /// </summary> 
    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> 
    protected override void Dispose(bool disposing) 
    { 
     if (disposing && (components != null)) 
     { 
      components.Dispose(); 
     } 
     base.Dispose(disposing); 
    } 

} 

Answer 4

spät zum Spiel, aber ich lief nur ein Szenario über zu Ihrer Frage, dass ich dachte, dass ich teilen. Wenn Sie Ihren Worker auf Klassenebene erstellen und ihn bei aufeinanderfolgenden Vorgängen wiederverwenden, ohne die Anwendung zu schließen, werden die Ereignisse bei jeder nachfolgenden Ausführung erhöht und mehrfach ausgeführt, wenn Sie die Ereignisse nach Abschluss nicht entfernen.

worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted); 
worker.DoWork -= new DoWorkEventHandler(worker_DoWork); 

Ohne die über mein DoWork Feuer einmal das erste Mal, zweimal das zweite Mal, etc. Dies ist wahrscheinlich ein Kinderspiel für die meisten, aber es hat mir ein bisschen, um es herauszufinden, hoffentlich diesen Willen hilf jemandem anderen.

Answer 5

worker.Dispose() ist nicht erforderlich, da Dispose() automatisch aufgerufen wird. Bevor Sie jedoch das Objekt entfernen, müssen Sie alle Ereignisbehandlungsroutinen entfernen.

Diese article informiert uns darüber.

worker.RunWorkerCompleted -= new RunWorkerCompletedEventHandle(worker_RunWorkerCompleted); 
worker.DoWork -= new DoWorkEventHandler(worker_DoWork);