Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original
Este tópico ainda não foi avaliado como - Avalie este tópico

Interface IDisposable

Define um método para liberar recursos alocados.

Namespace:  System
Assembly:  mscorlib (em mscorlib.dll)
[ComVisibleAttribute(true)]
public interface IDisposable

O tipo IDisposable expõe os membros a seguir.

  NomeDescrição
Método públicoCompatível com o XNA FrameworkCom suporte por Biblioteca de Classes PortátilCom suporte em .NET para aplicativos da Windows StoreDisposeRealiza tarefas definidas pelo aplicativo associadas à liberação ou à redefinição de recursos não gerenciados.
Superior

O uso principal dessa interface é para liberar recursos não-gerenciados. O coletor de lixo automaticamente libera a memória alocada para um objeto gerenciado quando este objeto não estiver mais sendo utilizado. No entanto, não é possível prever quando a coleta de lixo irá ocorrer. Além disso, o coletor de lixo não tem nenhum conhecimento de recursos não gerenciados como os identificadores de janela, ou arquivos abertos e passa.

Use o método Dispose desta interface para, explicitamente, liberar recursos não gerenciados em conjunto com o coletor de lixo. O consumidor de um objeto pode chamar esse método quando o objeto não for mais necessário.

É uma quebra de versão adicionar a interface IDisposable a uma classe existente, pois isto altera a semântica da classe.

Observação importanteImportante

Os desenvolvedores de C++ devem ler Destruidores e finalizadores no Visual C++. Na versão do .NET Framework, o compilador C++ fornece suporte para implementar uma liberação de recursos determinista e não permite a implementação do método Dispose diretamente.

Para uma detalhada discussão sobre como esta interface e o método Object.Finalize são usados, consulte os tópicos Coleta de Lixo e Implementando um método Dispose.

IDisposable e a hierarquia de herança

Uma classe base com subclasses que devem ser descartáveis deve implementar IDisposable da seguinte maneira:

  • Deve fornecer um método virtual não público de Dispose() e um método virtual protegido de Dispose(Boolean disposing) .

  • O método de Dispose() deve chamar Dispose(true) e deve eliminar o acabamento para desempenho.

  • O tipo base não deve incluir finalizadores.

As subclasses devem implementar o padrão descartável desta maneira:

  • Elas devem substituir Dispose(Boolean) e chamar a implementação Dispose(Boolean) da classe base.

  • Podem fornecer um finalizador, se necessário. O finalizador deve chamar Dispose(false).

Chamando a interface IDisposable

Ao chamar uma classe que implementa a interface IDisposable, use o try/finally padrão para certificar-se que recursos não gerenciados são descartados mesmo se uma exceção interrompa seu aplicativo.

Para mais informação sobre try/finally, veja Instrução Try...Catch...Finally (Visual Basic), try-finally (Referência de C#), ou Instrução try-finally (C).

Observe que você pode usar a declaração de using (Using no Visual Basic) em vez do padrão de try/finally . Para obter mais informações, consulte a documentação de Instrução Using (Visual Basic) ou a documentação de Instrução using (Referência de C#) .

O exemplo a seguir demonstra como criar um recurso classe que implementa a interface 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

Com suporte em: 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Com suporte em: 4, 3.5 SP1

Biblioteca de Classes Portátil

Com suporte em: Biblioteca de Classes Portátil

.NET para aplicativos da Windows Store

Com suporte em: Windows 8

Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (Função Server Core sem suporte), Windows Server 2008 R2 (Função Server Core com suporte com o SP1 ou posterior, Itanium sem suporte)

O .NET Framework não oferece suporte a todas as versões de cada plataforma. Para obter uma lista das versões com suporte, consulte Requisitos do sistema do .NET Framework.
Isso foi útil para você?
(1500 caracteres restantes)
Agradecemos os seus comentários

Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft. Todos os direitos reservados.