确定托管对象是否已被处置[重复]

简短的回答是“否”。IDispoable
接口不提供任何方法来告知用户代码实现该接口的实例实际上已被释放，而是由编写用户代码的开发人员以这样一种方式编写，即在不再需要实例时将其释放。

当然，您可以创建自己的接口，该接口继承自 IDisposable，添加一个 IsDisposed 属性，并使用实现此接口的类包装您的 IDisposable 类，但这仍然需要用户代码使用该属性才能从中受益。处理此问题的更好方法是修复使用 IDisposable 实例的代码。

.NET 对象处置功能与任何内存管理活动无关，因此它不是任何类型自动固有的。

自从实现了自动内存管理之后，对象析构函数就不再被确定地调用了。程序员应该自己注意释放非托管资源。.NET 中提出的标准方法是 IDisposable（由 c# 编译器使用 using 语句支持），但它可以是任何方式，这取决于程序员，并且应该明确实现。

仅当对象提供此类功能（例如，实现 IDisposable 并提供 IsDisposed 等附加属性）时，您才可以确定是否处置托管对象。

您需要将此功能嵌入到您需要监控的每种类型中。

PictureBox 实现了您需要处理的 Disposed 事件。不幸的是，它不是 IDisposable 的一部分，我们不应该在任何地方期待这个事件，而且其他 .NET 类型（例如 Stream）没有实现它。

调用 Dispose 方法不会终止对象。您可以根据需要以下列方式“处置”对象：

public class MyResource: IDisposable
{
    // Pointer to an external unmanaged resource.
    private IntPtr handle;

    // Other managed resource this class uses.
    private Component component = new Component();

    // Track whether Dispose has been called.
    private bool disposed = false;

    // To determine outside is object disposed or not
    public bool IsDisposed => disposed; 

    public MyResource(IntPtr handle) { this.handle = handle; }

    public NewHandle(IntPtr handle) {
        // Do not care about managed resources in demo
        this.handle = handle; disposed = false;
    }

    public void Dispose() => Dispose(disposing: true);

    // Dispose(bool disposing) executes in two distinct scenarios.
    // If disposing equals true, the method has been called directly
    // or indirectly by a user's code. Managed and unmanaged resources
    // can be disposed.
    // If disposing equals false, the method has been called by the
    // runtime from inside the finalizer and you should not reference
    // other objects. Only unmanaged resources can be disposed.
    protected virtual void Dispose(bool disposing)
    {
        // Check to see if Dispose has already been called.
        if(!this.disposed)
        {
            // If disposing equals true, dispose all managed
            // and unmanaged resources.
            if(disposing)
            {
                // Dispose managed resources.
                component.Dispose();
            }
            // Call the appropriate methods to clean up
            // unmanaged resources here.
            // If disposing is false,
            // only the following code is executed.
            CloseHandle(handle);
            handle = IntPtr.Zero;
            // Note disposing has been done.
            disposed = true;
        }
    }

    // Use interop to call the method necessary
    // to clean up the unmanaged resource.
    [System.Runtime.InteropServices.DllImport("Kernel32")]
    private extern static Boolean CloseHandle(IntPtr handle);

    // Use C# finalizer syntax for finalization code.
    // This finalizer will run only if the Dispose method
    // does not get called.
    // It gives your base class the opportunity to finalize.
    // Do not provide finalizer in types derived from this class.
    ~MyResource()
    {
        // Do not re-create Dispose clean-up code here.
        // Calling Dispose(disposing: false) is optimal in terms of
        // readability and maintainability.
        Dispose(disposing: false);
    }
}

...

using (var myres = new MyResource())
{
    myres.Dispose();
    // we can still use myres
    myres.NewHandle(new Handle());
}
// Disposed in the second time by leaving the using block.
// Since myres is the local variable in the block above
// the referenced object is released now and available for garbage collection
// but it's not related to object's disposing cycle.

// Alternatively:
var myres = new MyResource())
myres.Dispose();
myres.NewHandle(new Handle());
myres.Dispose();
myres = null;
// No way to interact with myres any more.
// The referenced object is released now and available for garbage collection.

如果应用程序没有达到内存限制，则在应用程序退出时调用析构函数。