Detectando objetos IDsposable "filtrados"

Question

Hay muchas preguntas SO preguntando cómo detectar fugas de objetos identificables. Parece que la respuesta es "you can't".

Acabo de comprobar con el caso de prueba más trivial, que FxCop 10.0 no lo hace, ReSharper 4 con MSVS2010 no lo hace.

Esto me parece incorrecto, peor que las pérdidas de memoria en C (para lo cual al menos hemos establecido herramientas para detectar).

Estaba pensando: ¿Es posible, utilizando la reflexión y otras técnicas avanzadas poco claras, que puedo inyectar un cheque en tiempo de ejecución, en el finalizador para ver si se ha llamado al Dispose?

¿Qué hay de trucos de magia con WinDBG + SOS?

Incluso si no hay herramientas existentes para hacerlo, me gustaría saber si esto es teóricamente posible (mi C# no es muy nítida).

Ideas?

NOTA El título de esta pregunta podría haber sido engañoso. La verdadera pregunta aquí debería ser si un objeto IDisposable ha sido Disposed() correctamente. Quedarme eliminado por el GC no cuenta ya que lo considero un error.

Editar: Solución: .NET Memory Profiler hace el trabajo. Solo debemos enviar varios correos electrónicos no deseados al GC.Collect() al final del programa para permitir que nuestro generador de perfiles pueda recoger las estadísticas correctamente.

Answer 1

No buscó lo suficiente. Hay muchos .NET Memory Profilers por ahí que verán su programa mientras se ejecuta y le permitirán saber dónde y cómo se usa su memoria (y qué se está filtrando).

Me echa un vistazo a cualquiera de los siguientes:

Microsoft's CLR Memory Profiler (free)
RedGate ANTS Memory Profiler
JetBrain's DotTrace (includes code profiler as well)
SciTech .NET Memory Profiler

actualización

.NET memoria Profiler de SciTech tiene una característica llamada 'Desechar Rastreador 'eso se ajusta a la factura de los OP's solicitud de rastrear solo las llamadas a Dispose en su aplicación.

Answer 2

puede hacerlo, agregando un Finalizador a sus objetos IDisposable. En el finalizador, puede verificar si el objeto ha sido eliminado o no. Si no se ha eliminado, puede afirmarlo o escribir algo en un registro, o lo que sea.

~Disposable() 
{ 
#if DEBUG 
      // In debug-builds, make sure that a warning is displayed when the Disposable object hasn't been 
      // disposed by the programmer. 

      if(_disposed == false) 
      { 
       System.Diagnostics.Debug.Fail ("There is a disposable object which hasn't been disposed before the finalizer call: {0}".FormatString (this.GetType().Name)); 
      } 
#endif 
      Dispose (false); 
} 

Usted puede factorizar esta funcionalidad en una clase base - Disposable - por ejemplo, que se puede utilizar como una plantilla para implementar el patrón Disposable por ejemplo.

Así, por ejemplo:

/// <summary> 
    /// Abstract base class for Disposable types.  
    /// </summary> 
    /// <remarks>This class makes it easy to correctly implement the Disposable pattern, so if you have a class which should 
    /// be IDisposable, you can inherit from this class and implement the DisposeManagedResources and the 
    /// DisposeUnmanagedResources (if necessary). 
    /// </remarks> 
    public abstract class Disposable : IDisposable 
    { 
     private bool     _disposed = false; 

     /// <summary> 
     /// Releases the managed and unmanaged resources. 
     /// </summary> 
     public void Dispose() 
     { 
      Dispose (true); 
      GC.SuppressFinalize (this); 
     } 

     /// <summary> 
     /// Releases the unmanaged and managed resources. 
     /// </summary> 
     /// <param name="disposing">When disposing is true, the managed and unmanaged resources are 
     /// released. 
     /// When disposing is false, only the unmanaged resources are released.</param> 
     [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly")] 
     protected void Dispose(bool disposing) 
     { 
      // We can suppress the CA1063 Message on this method, since we do not want that this method is 
      // virtual. 
      // Users of this class should override DisposeManagedResources and DisposeUnmanagedResources. 
      // By doing so, the Disposable pattern is also implemented correctly. 

      if(_disposed == false) 
      { 
       if(disposing) 
       { 
        DisposeManagedResources(); 
       } 
       DisposeUnmanagedResources(); 

       _disposed = true; 
      } 
     } 

     /// <summary> 
     /// Override this method and implement functionality to dispose the 
     /// managed resources. 
     /// </summary> 
     protected abstract void DisposeManagedResources(); 

     /// <summary> 
     /// Override this method if you have to dispose Unmanaged resources. 
     /// </summary> 
     protected virtual void DisposeUnmanagedResources() 
     { 
     } 

     /// <summary> 
     /// Releases unmanaged resources and performs other cleanup operations before the 
     /// <see cref="Disposable"/> is reclaimed by garbage collection. 
     /// </summary> 
     [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly")] 
     ~Disposable() 
     { 
#if DEBUG 
      // In debug-builds, make sure that a warning is displayed when the Disposable object hasn't been 
      // disposed by the programmer. 

      if(_disposed == false) 
      { 
       System.Diagnostics.Debug.Fail ("There is a disposable object which hasn't been disposed before the finalizer call: {0}".FormatString (this.GetType().Name)); 
      } 
#endif 
      Dispose (false); 
     } 
    } 

Answer 3

Si bien la recomendación de @Justin Niessner funciona, me parece que el uso de un generador de perfiles completo soplado demasiado pesado.

Creé mi solución de cocimiento casero: EyeDisposable. Instrumentos ensamblados para detectar cuando Dispose no han sido llamados.