Wykrywanie "wyciekanych" obiektów IDisposable

Question

Istnieje wiele pytań, w których można znaleźć wykrywanie wycieku obiektów IDisposable. Wygląda na to, że odpowiedź brzmi: "you can't".

Właśnie sprawdziłem z najbardziej trywialnym przypadkiem testowym, że FxCop 10.0 tego nie robi, ReSharper 4 z MSVS2010 tego nie robi.

Wydaje mi się to niewłaściwe, gorsze niż wycieki pamięci w C (dla których przynajmniej stworzyliśmy narzędzia do wykrywania).

Myślałem: Czy to możliwe, używając refleksji i innych niejasnych zaawansowanych technik, które mogę wprowadzić w runtime, w finalizatorze, aby sprawdzić, czy został wywołany Dispose?

Co powiecie na magiczne sztuczki z WinDBG + SOS?

Nawet jeśli nie ma na to narzędzi, chciałbym się dowiedzieć, czy jest to teoretycznie możliwe (moje C# nie jest zbyt ostre).

Pomysły?

UWAGA Tytuł tego pytania mógł być mylący. Prawdziwym pytaniem tutaj powinno być , czy obiekt IDisposable został odpowiednio Disposed(). Pozbycie się przez GC nie liczy się, ponieważ uważam to za błąd.

Edytuj: Rozwiązanie: .NET Profiler Memory wykonuje zadanie. Po zakończeniu programu musimy po prostu spisać kilka GC.Collect(), aby nasz profiler mógł poprawnie pobrać statystyki.

Answer 1

Nie szukałeś wystarczająco mocno. Dostępnych jest wiele Profili pamięci .NET, które będą przeglądać twój program podczas pracy i poinformować, gdzie i jak używana jest twoja pamięć (i co to jest wyciek).

chciałbym sprawdzić jedną z następujących czynności:

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

aktualizacji

SCITECH w .NET Memory Profiler ma funkcję o nazwie „Dispose Tracker "to pasuje do rachunku dla PO żądanie śledzenia tylko wywołań usuwania w ich aplikacji.

Answer 2

możesz to zrobić, dodając Finalizer do obiektów IDisposable. W finalizatorze można sprawdzić, czy obiekt został usunięty, czy nie. Jeśli nie została usunięta, możesz to potwierdzić lub napisać coś do dziennika, lub cokolwiek innego.

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

Można czynnik tej funkcji w klasie bazowej - Disposable - na przykład, który może być używany jako szablon do wdrożenia Disposable wzór na przykład.

Podoba Ci się to, na przykład:

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

Choć zalecenie @Justin Niessner za prace, uważam, że za pomocą pełnowartościowy profilera zbyt ciężkie.

Stworzyłem moje domowe rozwiązanie: EyeDisposable. Instrumentuje zespoły, aby wykryć, kiedy nie zostały wywołane, gdy Dispose.