How does one tell if an IDisposable object reference is disposed?

Question

Is there a method, or some other light-weight way, to check if a reference is to a disposed object?

P.S. - This is just a curiousity (sleep well, not in production code). Yes, I know I can catch the ObjectDisposedException upon trying to access a member of the object.

Answer 1

No - default implementation of IDisposable pattern does not support it

Answer 2

System.Windows.Forms.Control has an IsDisposed property which is set to true after Dispose() is called. In your own IDisposable objects, you can easily create a similar property.

Answer 3

There is nothing built in that will allow this. You would need to expose an IsDisposed boolean property that reflects an internal disposed flag.

public class SimpleCleanup : IDisposable
{
    private bool disposed = false;

    public bool IsDisposed
    {
       get
       {
          return disposed;
       }
    }

    public SimpleCleanup()
    {
        this.handle = /*...*/;
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
               // free only managed resources here
            }

            // free unmanaged resources here
            disposed = true;
        }
    }

    public void Dispose()
    {
        Dispose(true);
    }
}

Answer 4

If it is not your class and it doesn't provide an IsDisposed property (or something similar - the name is just a convention), then you have no way of knowing.

But if it is your class and you are following the canonical IDisposable implementation, then just expose the _disposed or _isDisposed field as a property and check that.

Answer 5

The Dispose method is required to perform whatever cleanup will be required before an object is abandoned; if no cleanup is required, it is not required to do anything. Requiring an object to keep track of whether it has been disposed, even when the Dispose method would otherwise do nothing, would require many IDisposable objects to add a flag for very limited benefit.

It might have been helpful if IDisposable included two properties--one which indicated whether an object needed disposing, and one of which indicated that the object had not been rendered useless by disposal. For objects where disposal actually does something, both values would be initially true, and would become false after Dispose. For objects where disposal doesn't need to do any cleanup, the first method could always return false and the second one always true, without having to store a flag anywhere. I don't think there's any way those can be added to .NET now, though.

Answer 6

I see this is old, but I did not see an answer. Some not all disposable objects like a DataSet have a disposed event you can attach.

class DisposeSample : IDisposable
{
    DataSet myDataSet = new DataSet();
    private bool _isDisposed;

    public DisposeSample()
    {
        // attach dispose event for myDataSet
        myDataSet.Disposed += MyDataSet_Disposed;
    }

    private void MyDataSet_Disposed(object sender, EventArgs e)
    {
        //Event triggers when myDataSet is disposed
        _isDisposed = true; // set private bool variable as true 
    }


    public void Dispose()
    {
        if (!_isDisposed) // only dispose if has not been disposed;
            myDataSet?.Dispose(); // only dispose if myDataSet is not null;
    }
}

Answer 7

A shortcut way to check if object is disposed using Extension method could be

public static class ObjectExtensions 
{
    public static bool IsDisposed(this object obj)
    {
        try
        {
            obj.ToString();
            return false;
        }
        catch (ObjectDisposedException)
        {
            return true;
        }
    }

}

//Usage
if(myObject.IsDisposed()){ 
    /* Do your Stuff */ 
}

Answer 8

What I like to do is declare the objects without initializing them, but set their default values to Nothing. Then, at the end of the loop I write:

If anObject IsNot Nothing Then anObject.Dispose()

Here is a complete sample:

Public Sub Example()
    Dim inputPdf As PdfReader = Nothing, inputDoc As Document = Nothing, outputWriter As PdfWriter = Nothing

    'code goes here that may or may not end up using all three objects, 
    ' such as when I see that there aren't enough pages in the pdf once I open  
    ' the pdfreader and then abort by jumping to my cleanup routine using a goto ..

GoodExit:
    If inputPdf IsNot Nothing Then inputPdf.Dispose()
    If inputDoc IsNot Nothing Then inputDoc.Dispose()
    If outputWriter IsNot Nothing Then outputWriter.Dispose()
End Sub

This also works great for putting your main objects at the top of a routine, using them inside a Try routine, and then disposing them in a Finally block:

Private Sub Test()
    Dim aForm As System.Windows.Forms.Form = Nothing
    Try
        Dim sName As String = aForm.Name  'null ref should occur
    Catch ex As Exception
        'got null exception, no doubt
    Finally
        'proper disposal occurs, error or no error, initialized or not..
        If aForm IsNot Nothing Then aForm.Dispose()
    End Try
End Sub