Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

IDisposable.Dispose (Método)

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

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

void Dispose()

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

Nota de precauciónPrecaución

Si está utilizando una clase que implemente la interfaz de IDisposable , debe llamar a la implementación de Dispose cuando termine de la clase. Para obtener más información, vea “Uso de objeto que implementa sección IDisposable” en el tema de IDisposable .

Cuando implemente este método, asegúrese de que se liberan todos los recursos utilizados mediante la propagación de 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 del método Dispose de A debe llamar a Dispose n B que, a su vez, debe llamar a Dispose en C.

Nota importanteImportante

Los programadores de C++ deben leer Destructores y Finalizadores en Visual C++. El compilador de C++ admite el aprovisionamiento determinista de recursos y no permite la implementación directa del método de Dispose .

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

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

Quizás los usuarios esperen que un tipo de recurso utilice una convención determinada para indicar un estado de asignación frente a un estado de liberación. Un ejemplo de esto son las clases de secuencia, que tradicionalmente se consideran como abiertas o cerradas. El implementador de una clase que tiene este convención podría implementar un método público con un nombre personalizado, como Close, que llama al método de Dispose .

Dado que el método de Dispose se debe denominar explícitamente, existe siempre el riesgo que no producirán liberar los recursos no administrados, porque el consumidor de un objeto no se llama al método de Dispose . Se puede evitar esto de dos maneras:

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

  • Implemente un finalizador para liberar recursos cuando Dispose no se denomina. 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 método de Dispose , normalmente es innecesario que el recolector de elementos no utilizados llame al finalizador del objeto desechado. Para evitar una finalización automática, las implementaciones de Dispose pueden llamar al método GC.SuppressFinalize.

Cuando se usa un objeto que tiene acceso a los recursos no administrados, como StreamWriter, es conveniente crear la instancia con una instrucción using. La instrucción using cierra el flujo automáticamente y llama a Dispose en el objeto cuando el código que está utilizándolo ha completado. Si necesita un ejemplo, vea la clase StreamWriter.

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


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.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Biblioteca de clases portable

Compatible con: Biblioteca de clases portable

.NET para aplicaciones de la Tienda Windows

Compatible con: Windows 8

.NET para aplicaciones de Windows Phone

Compatible con: Windows Phone 8, Silverlight 8.1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.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.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft