¿Por qué invocar dispose (false) en el destructor?

Question

Lo que sigue es un ejemplo típico patrón de disponer:

public bool IsDisposed { get; private set; } 

    #region IDisposable Members 

    public void Dispose() 
    { 
    Dispose(true); 
    GC.SuppressFinalize(this); 
    } 

    protected virtual void Dispose(bool disposing) 
    { 
    if (!IsDisposed) 
    { 
     if (disposing) 
     { 
     //perform cleanup here 
     } 

     IsDisposed = true; 
    } 
    } 

    ~MyObject() 
    { 
    Dispose(false); 
    } 

entiendo lo deseche hace, pero lo que no entiendo es por qué usted quiere llamar a disponer (falso) en el destructor? Si nos fijamos en la definición, no haría absolutamente nada, entonces ¿por qué alguien escribiría un código como este? ¿No tendría sentido simplemente llamar deshacerse del destructor?

Answer 1

El finalizador se utiliza como un recurso si el objeto no está dispuesto adecuadamente por alguna razón. Normalmente se llamaría al método Dispose(), que elimina la conexión del finalizador y convierte el objeto en un objeto administrado regular que el recolector de basura puede eliminar fácilmente.

Aquí hay un ejemplo de MSDN de una clase que tiene recursos administrados y no administrados para limpiar.

Observe que los recursos administrados solo se limpian si disposing es verdadero, pero los recursos no administrados siempre se limpian.

public class MyResource: IDisposable 
{ 
    // Pointer to an external unmanaged resource. 
    private IntPtr handle; 
    // Other managed resource this class uses. 
    private Component component = new Component(); 
    // Track whether Dispose has been called. 
    private bool disposed = false; 

    // The class constructor. 
    public MyResource(IntPtr handle) 
    { 
     this.handle = handle; 
    } 

    // Implement IDisposable. 
    // Do not make this method virtual. 
    // A derived class should not be able to override this method. 
    public void Dispose() 
    { 
     Dispose(true); 
     // This object will be cleaned up by the Dispose method. 
     // Therefore, you should call GC.SupressFinalize to 
     // take this object off the finalization queue 
     // and prevent finalization code for this object 
     // from executing a second time. 
     GC.SuppressFinalize(this); 
    } 

    // Dispose(bool disposing) executes in two distinct scenarios. 
    // If disposing equals true, the method has been called directly 
    // or indirectly by a user's code. Managed and unmanaged resources 
    // can be disposed. 
    // If disposing equals false, the method has been called by the 
    // runtime from inside the finalizer and you should not reference 
    // other objects. Only unmanaged resources can be disposed. 
    private void Dispose(bool disposing) 
    { 
     // Check to see if Dispose has already been called. 
     if(!this.disposed) 
     { 
      // If disposing equals true, dispose all managed 
      // and unmanaged resources. 
      if(disposing) 
      { 
       // Dispose managed resources. 
       component.Dispose(); 
      } 

      // Call the appropriate methods to clean up 
      // unmanaged resources here. 
      // If disposing is false, 
      // only the following code is executed. 
      CloseHandle(handle); 
      handle = IntPtr.Zero; 

      // Note disposing has been done. 
      disposed = true; 

     } 
    } 

    // Use interop to call the method necessary 
    // to clean up the unmanaged resource. 
    [System.Runtime.InteropServices.DllImport("Kernel32")] 
    private extern static Boolean CloseHandle(IntPtr handle); 

    // Use C# destructor syntax for finalization code. 
    // This destructor will run only if the Dispose method 
    // does not get called. 
    // It gives your base class the opportunity to finalize. 
    // Do not provide destructors in types derived from this class. 
    ~MyResource() 
    { 
     // Do not re-create Dispose clean-up code here. 
     // Calling Dispose(false) is optimal in terms of 
     // readability and maintainability. 
     Dispose(false); 
    } 
} 

Answer 2

No hay destructores en C#. Eso es un Finalizer, que es algo diferente.

La distinción es si necesita limpiar objetos administrados o no. No desea intentar limpiarlos en el finalizador, ya que ellos mismos pueden haber sido finalizados.

---

Sólo recientemente se pasó a mirar la página Destructors de la Guía de programación de C#. Muestra que estaba equivocado en mi respuesta, arriba. En particular, hay una diferencia entre el destructor y el finalizador:

class Car 
{ 
    ~Car() // destructor 
    { 
     // cleanup statements... 
    } 
} 

es equivalente a

protected override void Finalize() 
{ 
    try 
    { 
     // Cleanup statements... 
    } 
    finally 
    { 
     base.Finalize(); 
    } 
} 

Answer 3

"La idea aquí es que Dispose (Boolean) sabe si se siendo llamado a hacer una limpieza explícita (el Booleano es verdadero) versus ser llamado debido a una recolección de basura (el Booleano es falso). Esta distinción es útil porque, cuando estando dispuestos de forma explícita, el método Dispose (Boolean) con seguridad puede ejecutar código utilizando el tipo de referencia campos que hacen referencia a otros objetos sabiendo con certeza que estos otros objetos no se han concluido o eliminados todavía. Cuando el booleano es falso, el Dispose (Boolean) Método no debería ejecutar código que se refieren a campos de tipo de referencia porque esos objetos pueden ya han sido finalizado."

Hay mucha más información en la “Dispose, Finalization, and Resource Management Design Guidelines” .

Editar:. enlace

Answer 4

Dentro del caso (desechar) que se supone que llamar a desechar/cierre en los objetos administrados que tienen recursos no administrados (por ejemplo, conexiones de base de datos) .Cuando el finalizador está llamado a estos ob Los objetos ya no se pueden alcanzar, por lo que los objetos mismos se pueden finalizar y no es necesario llamarlos para disponer de ellos. Además, el orden de finalización no está terminado, por lo que puede estar llamando a deshacerse de los objetos ya dispuestos.

Answer 5

Creo que la confusión se debe al hecho de que en su ejemplo no está liberando ningún recurso no administrado. También deben liberarse cuando se solicite el desecho a través de la recolección de basura y se liberarían fuera de el cheque para disposing. Consulte el ejemplo de MSDN relacionado con releasing unmanaged resources. El otro que eso/debería ocurrir fuera del cheque es una llamada a cualquier método de eliminación de la clase base.

Desde el artículo citado:

protected override void Dispose(bool disposing) 
    { 
     if (disposing) 
     { 
     // Release managed resources. 
     } 
     // Release unmanaged resources. 
     // Set large fields to null. 
     // Call Dispose on your base class. 
     base.Dispose(disposing); 
    }