Rilevamento di oggetti identificabili "fuoriusciti"

Question

Ci sono molte domande, quindi, che si chiede come rilevare la perdita di oggetti IDisposable. Sembra che la risposta sia "you can't".

Ho appena controllato con il caso di test più banale, che FxCop 10.0 non lo fa, ReSharper 4 con MSVS2010 non lo fa.

Questo mi sembra sbagliato, peggio di perdite di memoria in C (per il quale almeno abbiamo stabilito strumenti per rilevare).

Stavo pensando: è possibile, utilizzando la riflessione e altre tecniche avanzate oscure, che posso iniettare un controllo in fase di esecuzione, nel finalizzatore per vedere se è stato chiamato Dispose?

E i trucchi magici con WinDBG + SOS?

Anche se non ci sono strumenti esistenti per farlo, mi piacerebbe sapere se questo è teoricamente possibile (il mio C# non è molto nitido).

Idee?

NOTA Il titolo di questa domanda potrebbe essere fuorviante. La vera domanda qui dovrebbe essere se un oggetto IDisposable è stato Disposed() correttamente. Ottenere smaltito dal GC non conta perché lo considero un errore.

Modifica: Soluzione: .NET Memory Profiler fa il lavoro. Abbiamo solo bisogno di inviare spam diversi GC.Collect() alla fine del programma per consentire al nostro profiler di raccogliere correttamente le statistiche.

Answer 1

Non hai cercato abbastanza. Ci sono molti Profiler di memoria .NET là fuori che guarderanno il tuo programma mentre è in esecuzione e ti faranno sapere dove/come viene utilizzata la tua memoria (e cosa sta perdendo).

avrei fatto il check out uno dei seguenti:

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

Aggiornamento

di SciTech NET Memory Profiler ha una funzione chiamata 'Smaltire Tracker 'che si adatta al conto per gli OP richiesta di tenere traccia solo delle chiamate Dispose nella loro applicazione.

Answer 2

puoi farlo aggiungendo un Finalizzatore ai tuoi oggetti IDisposable. Nel finalizzatore, è possibile verificare se l'oggetto è stato eliminato o meno. Se non è stato eliminato, puoi dichiararlo o scrivere qualcosa su un registro o altro.

~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); 
} 

È possibile fattore questa funzionalità in una classe di base - Disposable - per esempio, che può essere utilizzato come modello per implementare il modello Disposable per esempio.

In questo modo, per esempio:

/// <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

Mentre la raccomandazione di @Justin Niessner funziona, trovo che l'utilizzo di un profiler in piena regola troppo pesante.

Ho creato la mia soluzione di home-brew: EyeDisposable. Esso assembli gli strumenti per rilevare quando non sono stati chiamati Dispose.