检测“泄露”的 IDisposable 对象

Question

有很多问题询问如何检测 IDisposable 对象泄漏。答案似乎是"you can't"。

我刚刚检查了最简单的测试用例，FxCop 10.0 不这样做，ReSharper 4 with MSVS2010 不这样做。

这对我来说似乎是错误的，比 C 中的内存泄漏更糟糕（至少我们已经建立了检测工具）。

我在想：是否有可能，使用反射和其他模糊的高级技术，我可以在运行时在终结器中注入检查以查看是否已调用 Dispose？

WinDBG+SOS 的魔术怎么样？

即使没有现成的工具可以做到这一点，我想知道这在理论上是否可行（我的 C# 不是很敏锐）。

想法？

注意 此问题的标题可能具有误导性。这里真正的问题应该是IDisposable 对象是否正确地是Disposed()。被 GC 处理掉不算数，因为我认为这是一个错误。

编辑：解决方案：.NET Memory Profiler 完成这项工作。我们只需要在程序结束时向多个GC.Collect() 发送垃圾邮件，以使我们的分析器能够正确获取统计信息。

Answer 1

你搜索的不够仔细。有很多 .NET 内存分析器可以在程序运行时查看它，并让您知道内存的使用位置/方式（以及泄漏的原因）。

我会检查以下任何一项：

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

更新

SciTech 的 .NET Memory Profiler 有一个名为“Dispose Tracker”的功能，可以满足 OP 仅跟踪其应用程序中的 Dispose 调用的要求。

Answer 2

您可以通过向您的 IDisposable 对象添加终结器来做到这一点。 在终结器中，您可以检查对象是否已被释放。如果它没有被释放，你可以断言它，或者在日志中写一些东西，或者其他什么。

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

您可以将此功能分解到基类 -Disposable- 中，例如，它可以用作模板来实现 Disposable 模式。

例如这样：

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

虽然@Justin Niessner 的推荐有效，但我发现使用完整的分析器过于繁重。

我创建了我的自制解决方案：EyeDisposable。它检测程序集以检测何时未调用 Dispose。