Forma correcta de deshacerse de un BackGroundWorker

Question

¿Esta sería una forma adecuada de deshacerse de un BackGroundWorker? No estoy seguro de si es necesario eliminar los eventos antes de llamar a .Dispose(). También está llamando .Dispose() dentro del delegado RunWorkerCompleted para hacer?

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 se deriva de Component. El componente implementa la interfaz IDisposable. Eso a su vez hace que BackgroundWorker herede el método Dispose().

Derivado de componentes es una conveniencia para los programadores de Windows Forms, pueden colocar un BGW de la caja de herramientas en un formulario. Es probable que los componentes en general tengan algo que desechar. El diseñador de Windows Forms se ocupa de esto automáticamente, busque en el archivo Designer.cs un Formulario para el campo "componentes". Su método Dispose() generado automáticamente llama al método Dispose() para todos los componentes.

Sin embargo, BackgroundWorker en realidad no tiene ningún miembro que requiera su eliminación. No anula Dispose(). Su implementación base, Component.Dispose(), solo se asegura de que el componente se elimine de la colección de "componentes". Y levanta el evento Disposed. Pero de otro modo no dispone de nada.

Resumen breve: si eliminó un BGW en un formulario, entonces todo se soluciona automáticamente, no tiene que ayudar. Si no lo colocó en un formulario, entonces no es un elemento en una colección de componentes y no es necesario hacer nada.

No tiene que llamar a Dispose().

Answer 2

Sí, esto parece correcto. Por supuesto, los objetos desechables se manejan mejor con los bloques using, pero no tiene esa opción aquí.

Por lo general, creo mis ejecuciones de segundo plano con vidas útiles, las vuelvo a usar, y dejo que el código del diseñador maneje la eliminación en forma cerrada. Menos para pensar.

Answer 3

Si está en un "Windows Forms" Formulario de dejar que el contenedor se encargue de ello (ver el código Dispose generado en el archivo Form.Designer.xyz)

En la práctica, he encontrado que es posible que deba crear una ejemplo del contenedor y agregue el trabajador (u otra compañía), si alguien conoce una forma más oficial de hacerlo, ¡grite!

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

tarde al juego, pero sólo encontré con un escenario relacionado a su pregunta que pensé que iba a compartir. Si crea su trabajador en el nivel de clase y lo reutiliza en operaciones sucesivas sin cerrar la aplicación, si no elimina los eventos después de la finalización, se incrementarán y ejecutarán varias veces en cada ejecución sucesiva.

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

Sin lo anterior mis fuegos DoWork una vez que la primera vez, dos veces el segundo tiempo, etc. Esto es probablemente una obviedad para la mayoría, pero me tomó un poco de entenderlo, así que espero que esta voluntad ayudar a alguien más a salir.

Answer 5

worker.Dispose() no se requiere, porque Dispose() se llama automáticamente. Pero antes de eliminar el objeto, debe eliminar todos los controladores de eventos.

Esto article nos informa sobre esto.

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