IDisposable.Dispose Método

Definición

Espacio de nombres:

System

Ensamblados:

netstandard.dll, System.Runtime.dll

Realiza tareas definidas por la aplicación asociadas a la liberación o al restablecimiento de recursos no administrados.

C#

public void Dispose();

Ejemplos

En el ejemplo siguiente se muestra cómo se puede implementar el Dispose método .

C#

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(disposing: true);
            // This object will be cleaned up by the Dispose method.
            // Therefore, you should call GC.SuppressFinalize 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# 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);
        }
    }
    public static void Main()
    {
        // Insert code here to create
        // and use the MyResource object.
    }
}

Comentarios

Use este método para cerrar o liberar recursos no administrados, como archivos, secuencias y identificadores mantenidos por una instancia de la clase que implementa esta interfaz. Por convención, este método se usa para todas las tareas asociadas a liberar recursos mantenidos por un objeto o preparar un objeto para su reutilización.

Advertencia

Si usa una clase que implementa la IDisposable interfaz, debe llamar a su Dispose implementación cuando haya terminado de usar la clase . Para obtener más información, vea la sección "Uso de un objeto que implementa IDisposable" en el IDisposable tema.

Al implementar este método, asegúrese de que todos los recursos retenidos se liberen propagando la llamada a través de la jerarquía de contención. Por ejemplo, si un objeto A asigna un objeto B y el objeto B asigna un objeto C, la implementación de Dispose A debe llamar a Dispose en B, que a su vez debe llamar a Dispose C.

Importante

El compilador de C++ admite la eliminación determinista de recursos y no permite la implementación directa del Dispose método .

Un objeto también debe llamar al Dispose método de su clase base si la clase base implementa IDisposable. Para obtener más información sobre la implementación IDisposable en una clase base y sus subclases, vea la sección "IDisposable y la jerarquía de herencia" del IDisposable tema.

Si se llama al método de Dispose un objeto más de una vez, el objeto debe omitir todas las llamadas después de la primera. El objeto no debe producir una excepción si se llama a su Dispose método varias veces. Los métodos de instancia distintos Dispose de pueden producir una ObjectDisposedException excepción cuando ya se eliminan los recursos.

Los usuarios pueden esperar que un tipo de recurso use una convención determinada para indicar un estado asignado frente a un estado liberado. Un ejemplo de esto es las clases de flujo, que tradicionalmente se consideran como abiertas o cerradas. El implementador de una clase que tiene esta convención podría optar por implementar un método público con un nombre personalizado, como Close, que llama al Dispose método .

Dado que se Dispose debe llamar al método explícitamente, siempre hay un peligro de que los recursos no administrados no se liberen, porque el consumidor de un objeto no puede llamar a su Dispose método. Existen dos formas de evitarlo:

• Ajuste del recurso administrado en un objeto derivado de System.Runtime.InteropServices.SafeHandle. A Dispose continuación, la implementación llama al Dispose método de las System.Runtime.InteropServices.SafeHandle instancias. Para obtener más información, vea la sección "La alternativa SafeHandle" en el Object.Finalize tema.

• Implemente un finalizador para liberar recursos cuando Dispose no se llama a . De forma predeterminada, el recolector de elementos no utilizados llama automáticamente al finalizador de un objeto antes de reclamar su memoria. Sin embargo, si se ha llamado al Dispose método , normalmente no es necesario que el recolector de elementos no utilizados llame al finalizador del objeto eliminado. Para evitar la finalización automática, Dispose las implementaciones pueden llamar al GC.SuppressFinalize método .

Cuando se usa un objeto que tiene acceso a recursos no administrados, como , StreamWriterse recomienda crear la instancia con una using instrucción . La using instrucción cierra automáticamente la secuencia y llama Dispose al objeto cuando se ha completado el código que lo usa. Para obtener un ejemplo, vea la StreamWriter clase .

Se aplica a

Consulte también

• Implementación de un método Dispose