Para ver el artículo en inglés, active la casilla Inglés. También puede ver el texto en inglés en una ventana emergente si pasa el puntero del mouse por el texto.
Traducción
Inglés
Esta documentación está archivada y no tiene mantenimiento.

IDisposable (Interfaz)

Define un método para liberar los recursos asignados.

Espacio de nombres:  System
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public interface IDisposable

El tipo IDisposable expone los siguientes miembros.

  NombreDescripción
Método públicoCompatible con XNA Frameworkaax125c9.PortableClassLibrary(es-es,VS.100).gifDisposeRealiza tareas definidas por la aplicación asociadas a la liberación o al restablecimiento de recursos no administrados.
Arriba

Esta interfaz se usa principalmente para liberar los recursos no administrados. El recolector de elementos no utilizados libera automáticamente la memoria asignada a un objeto administrado cuando ya no se utiliza ese objeto. Sin embargo, no se puede prever cuándo se producirá la recolección de elementos no utilizados. Además, el recolector de elementos no utilizados no reconoce recursos no administrados tales como los identificadores de ventana, o las secuencias y archivos abiertos.

Utilice el método Dispose de esta interfaz para liberar recursos no administrados explícitamente junto con el recolector de elementos no utilizados. El consumidor de un objeto puede llamar a este método cuando el objeto deja de ser necesario.

Agregar la interfaz IDisposable a una clase existente da lugar a un cambio importante en la versión, puesto que cambia la semántica de la clase.

Nota importanteImportante

Los programadores de C++ deben leer Destructors and Finalizers in Visual C++. En .NET Framework, el compilador de C++ proporciona compatibilidad para implementar una eliminación determinística de los recursos y no permite la implementación directa del método Dispose.

Para obtener información detallada sobre la forma de utilizar esta interfaz y el método Object.Finalize, vea los temas recolección de elementos no utilizados y Implementar un método Dispose.

Llamar a la interfaz IDisposable

Cuando llame a una clase que implementa la interfaz IDisposable, utilice el modelo try/finally para asegurarse de que se eliminan los recursos no administrados aunque una excepción interrumpa la aplicación.

Para obtener más información sobre el modelo try/finally, vea Instrucción Try...Catch...Finally (Visual Basic), try-finally (Referencia de C#) o try-finally Statement (C).

Observe que puede utilizar la instrucción using (Using en Visual Basic) en lugar del modelo try/finally. Para obtener más información, consulte la documentación de Using (Instrucción, Visual Basic) o using (Instrucción, Referencia de C#).

En el siguiente ejemplo de código se muestra cómo se crea una clase de recurso que implementa la interfaz IDisposable.


using System;
using System.ComponentModel;

// The following example demonstrates how to create
// a resource class that implements the IDisposable interface
// and the IDisposable.Dispose method.

public class DisposeExample
{
    // A base class that implements IDisposable.
    // By implementing IDisposable, you are announcing that
    // instances of this type allocate scarce resources.
    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;

        // The class constructor.
        public MyResource(IntPtr handle)
        {
            this.handle = handle;
        }

        // Implement IDisposable.
        // Do not make this method virtual.
        // A derived class should not be able to override this method.
        public void Dispose()
        {
            Dispose(true);
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SupressFinalize to
            // take this object off the finalization queue
            // and prevent finalization code for this object
            // from executing a second time.
            GC.SuppressFinalize(this);
        }

        // 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# destructor syntax for finalization code.
        // This destructor will run only if the Dispose method
        // does not get called.
        // It gives your base class the opportunity to finalize.
        // Do not provide destructors in types derived from this class.
        ~MyResource()
        {
            // Do not re-create Dispose clean-up code here.
            // Calling Dispose(false) is optimal in terms of
            // readability and maintainability.
            Dispose(false);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.
    }
}


.NET Framework

Compatible con: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Compatible con:

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.
Mostrar: