¿Cómo se sabe si se elimina una referencia de objeto IDisposable?

¿Existe un método, o alguna otra forma liviana, para verificar si una referencia es a un objeto desechado?

PD - Esto es solo una curiosidad (duerma bien, no en código de producción). Sí, sé que puedo detectarlo ObjectDisposedExceptional intentar acceder a un miembro del objeto.

No, la implementación predeterminada del patrón IDisposable no lo admite

System.Windows.Forms.Controltiene una IsDisposedpropiedad que se establece en true después de que Dispose()se llame . En sus propios objetos IDisposable, puede crear fácilmente una propiedad similar.

No hay nada integrado que lo permita. Debería exponer una propiedad booleana IsDisposed que refleje una marca de disposición interna.

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

Si no es su clase y no proporciona una propiedad IsDisposed (o algo similar, el nombre es solo una convención), entonces no tiene forma de saberlo.

Pero si es su clase y está siguiendo la implementación canónica IDisposable , simplemente exponga el campo _disposed o _isDisposed como una propiedad y verifique eso.

El Disposemétodo es necesario para realizar cualquier limpieza necesaria antes de que se abandone un objeto; si no se requiere limpieza, no se requiere hacer nada. Exigir que un objeto realice un seguimiento de si se ha eliminado, incluso cuando el Disposemétodo no haría nada de otra manera, requeriría que muchos IDisposableobjetos agreguen una bandera para un beneficio muy limitado.

Podría haber sido útil IDisposableincluir dos propiedades: una que indicaba si un objeto necesitaba desecharse y otra que indicaba que el objeto no se había vuelto inútil por desecho. Para los objetos en los que la eliminación realmente hace algo, ambos valores serían inicialmente verdaderos y luego se volverían falsos Dispose. Para los objetos en los que la eliminación no necesita realizar ninguna limpieza, el primer método siempre podría devolver falso y el segundo siempre verdadero, sin tener que almacenar una bandera en ningún lugar. Sin embargo, no creo que haya ninguna forma de agregarlos a .NET ahora.

Veo que esto es antiguo, pero no vi una respuesta. Algunos no todos los objetos desechables como un DataSet tienen un evento desechado que puede adjuntar.

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

Lo que me gusta hacer es declarar los objetos sin inicializarlos, pero establecer sus valores predeterminados en Nothing. Luego, al final del ciclo escribo:

If anObject IsNot Nothing Then anObject.Dispose()

Aquí tienes una muestra completa:

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

Esto también funciona muy bien para colocar sus objetos principales en la parte superior de una rutina, usarlos dentro de una Tryrutina y luego desecharlos en un Finallybloque:

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