Un moyen correct d'éliminer un BackGroundWorker

Question

Est-ce que ce serait une bonne façon de disposer d'un BackGroundWorker? Je ne suis pas sûr s'il est nécessaire de supprimer les événements avant d'appeler .Dispose(). Appelle également .Dispose() dans le délégué RunWorkerCompleted ok à faire?

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 dérive de Component. Component implémente l'interface IDisposable. Cela à son tour rend BackgroundWorker hériter de la méthode Dispose(). Dériver de Component est une commodité pour les programmeurs Windows Forms, ils peuvent déposer un BGW de la boîte à outils sur un formulaire. Les composants en général sont susceptibles d'avoir quelque chose à éliminer. Le concepteur Windows Forms s'en charge automatiquement. Dans le fichier Designer.cs, recherchez un formulaire pour le champ "composants". Sa méthode Dispose() générée automatiquement appelle la méthode Dispose() pour tous les composants. Toutefois, BackgroundWorker ne possède aucun membre nécessitant une mise au rebut. Il ne remplace pas Dispose(). Son implémentation de base, Component.Dispose(), s'assure seulement que le composant est retiré de la collection "components". Et augmentez l'événement Disposed. Mais ne dispose pas autrement. Longue histoire courte: si vous avez laissé tomber un BGW sur un formulaire alors tout est pris en charge automatiquement, vous n'avez pas besoin d'aide. Si vous ne l'avez pas déposé sur un formulaire, ce n'est pas un élément dans une collection de composants et rien ne doit être fait.

Vous ne devez pas appeler Dispose().

Answer 2

Oui, cela semble correct. Bien sûr, les objets jetables sont mieux gérés avec les blocs using, mais vous n'avez pas cette option ici.

Je crée généralement mes gestionnaires d'arrière-plan avec des durées de vie de formulaire, les réutilise et laisse le code du concepteur gérer la mise au rebut sur le formulaire. Moins à penser.

Answer 3

S'il est sur un « WinForms » Formulaire laisser le récipient prendre soin (voir le code Dispose généré dans le fichier Form.Designer.xyz)

Dans la pratique, j'ai trouvé que vous devrez peut-être créer un exemple du conteneur et ajouter le travailleur (ou autre compagnon) à celui-ci, si quelqu'un sait une façon plus officielle de le faire crier !!

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

tard pour le jeu, mais je suis tombé sur un scénario lié à votre question que je pensais que je voudrais partager. Si vous créez votre worker au niveau de la classe et que vous le réutilisez lors d'opérations successives sans fermer l'application, si vous ne supprimez pas les événements après leur exécution, ils seront incrémentés et exécutés plusieurs fois à chaque exécution successive.

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

Sans-dessus de mes feux de DoWork une fois la première fois, deux fois la deuxième fois, etc. Ceci est probablement une évidence pour la plupart, mais il m'a fallu un peu pour le comprendre, donc nous espérons que cette volonté aider quelqu'un d'autre.

Answer 5

worker.Dispose() n'est pas requis car Dispose() est automatiquement appelé. Mais avant de disposer de l'objet, vous devez supprimer tous les gestionnaires d'événements.

Cette article nous informe à ce sujet.

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