检测“泄漏” I一次性对象

Question

有很多问题询问如何检测 IDisposable 对象泄漏。答案似乎是“你不能”。

我刚刚检查了最简单的测试用例，FxCop 10.0 没有这样做，带有 MSVS2010 的 ReSharper 4 也没有这样做。

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

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

WinDBG+SOS 的魔术怎么样？

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

有想法吗？

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

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

Answer 1

你搜索得不够努力。有很多 .NET 内存分析器可以在程序运行时查看您的程序，并让您知道内存在何处/如何使用（以及泄漏的情况）。

我会检查以下任何内容：

Microsoft 的 CLR 内存分析器（免费）
RedGate ANTS 内存分析器
JetBrain 的 DotTrace（还包括代码分析器）
SciTech .NET Memory Profiler

更新

SciTech 的 .NET Memory Profiler 有一个名为“ Dispose Tracker' 符合 OP 仅跟踪其应用程序中的 Dispose 调用的请求。

Answer 2

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

 ~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 - 中，该基类可用作实现 一次性 模式。

像这样，例如：

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