Como objetos são criados e destruídos Outros recursos

  • Artigo

Uma instância de uma classe, um objeto, é criada usando o New palavra-chave. Tarefas de inicialização geralmente devem ser executadas em novos objetos antes de serem usadas.Tarefas comuns de inicialização incluem a abertura de arquivos, conectar-se a bancos de dados e ler valores de chaves do registro.Visual Basic controla a inicialização de novos objetos usando os procedimentos chamados construtores (métodos especiais que permitem o controle sobre a inicialização).

Após um objeto sai do escopo, ela foi lançada pelo common linguagem tempo de execução (CLR).Visual Basic controla o versão dos recursos do sistema usando os procedimentos chamados destruidores.Juntos, construtores e destrutores oferecem suporte à criação de bibliotecas de classes robusto e previsível.

Sub-rotina New e Sub Finalize

The Sub New e Sub Finalize procedimentos no Visual Basic inicializar e destruir objetos; eles substituir o Class_Initialize e Class_Terminate métodos usados no Visual Basic versões 6.0 e anteriores. Ao contrário de Class_Initialize, o Sub New construtor pode ser executadas somente uma vez quando uma classe é criada. Não é possível chamar explicitamente em qualquer lugar diferente na primeira linha do código de Outros construtor a partir da mesma classe ou uma classe derivada.Além disso, o código a Sub New método sempre é executado antes de qualquer Outros código em uma classe. Visual Basic 2005 e versões posteriores criam implicitamente um Sub New construtor em time de execução se você não definir explicitamente um Sub New procedimento para uma classe.

Antes de soltar objetos, o CLR chama automaticamente o Finalize método para objetos que definem um Sub Finalize procedimento. The Finalize método pode conter código que precisa para executar apenas antes que um objeto é destruído, tais sistema autônomo códigos fecham arquivos e salvar informações de estado. Existe uma penalidade de desempenho pequeno para executar o Sub Finalize, portanto, você deve definir um Sub Finalize método somente quando você precisa versão explicitamente os objetos.

Observação:

O coletor de lixo do CLR não (e não pode) descartar objetos não gerenciados, objetos do sistema operacional é executado diretamente, fora do ambiente do CLR.Isso ocorre porque diferentes objetos não gerenciados devem ser descartados de maneiras diferentes.Essas informações não é diretamente associadas ao objeto não gerenciado; ele deve ser encontrado na documentação para o objeto.Uma classe que usa objetos não gerenciados deve descartá-los no seu Finalize método.

The Finalize destruidor é um método protegido que pode ser chamado apenas de classe que ele pertence ou de classes derivadas. O sistema chama Finalize automaticamente quando um objeto é destruído, portanto, você não deve explicitamente chamar Finalize de fora de uma classe derivada Finalize implementação.

Ao contrário de Class_Terminate, que é executado assim que um objeto é definido sistema autônomo nada, normalmente há um atraso entre quando um objeto perde o escopo e ao Visual Basic chama a Finalize destruidor. Visual Basic 2005 e versões posteriores permitem um segundo tipo de destruidor, Dispose, que pode ser chamado explicitamente a qualquer momento para liberar recursos imediatamente.

Observação:

A Finalize destrutor não deve lançar exceções, porque eles não podem ser manipulados pelo aplicativo e podem fazer com que o aplicativo terminar.

Interface IDisposable

Instâncias da classe geralmente controlam recursos não gerenciado pelo CLR, sistema autônomo Windows alças e conexões de banco de dados.Esses recursos devem ser descartados no Finalize método da classe, para que eles serão liberados quando o objeto é destruído pelo coletor de lixo. No entanto, o coletor de lixo destrói objetos apenas quando o CLR requer mais memória disponível.Isso significa que os recursos podem não ser liberados até o tempo após o objeto sai do escopo.

Para complementar o lixo coleção, suas classes podem fornecer um mecanismo de gerenciar ativamente os recursos do sistema se implementam o IDisposable interface. IDisposable tem um método, Dispose, os clientes que devem telefonar quando terminarem usando um objeto. Você pode usar o Dispose método para imediatamente versão recursos e executar tarefas sistema autônomo fechar arquivos e conexões de banco de dados. Ao contrário de Finalize destruidor, o Dispose método não é chamado automaticamente. Clientes de uma classe devem chamar explicitamente Dispose Quando você desejar imediatamente versão recursos.

Implementação de IDisposable

Uma classe que implementa o IDisposable interface deve incluir essas seções de código:

  • Um campo para controlar se o objeto foi descartado:

    Protected disposed As Boolean = False

  • Uma sobrecarga do Dispose que libera recursos da classe. Esse método deve ser chamado pelo Dispose e Finalize métodos da classe base:

    Protected Overridable Sub Dispose(ByVal disposing As Boolean)
    If Not Me.disposed Then
        If disposing Then
            ' Insert code to free managed resources.
        End If
        ' Insert code to free unmanaged resources.
    End If
    Me.disposed = True
End Sub

  • Uma implementação de Dispose que contém somente o código a seguir:

    Public Sub Dispose() Implements IDisposable.Dispose
    Dispose(True)
    GC.SuppressFinalize(Me)
End Sub

  • Uma substituir do Finalize método que contém somente o código a seguir:

    Protected Overrides Sub Finalize()
    Dispose(False)
    MyBase.Finalize()
End Sub

Derivar de uma classe que implementa IDisposable

Uma classe que deriva de uma classe base que implementa o IDisposable interface não é necessário substituir qualquer um dos métodos de base, a menos que ele usa os recursos adicionais que precisam ser eliminado. Nessa situação, a classe derivada deve substituir Dispose(disposing) método para descartar os recursos da classe derivada. Isso substituir deve telefonar Dispose(disposing) método.

Protected Overrides Sub Dispose(ByVal disposing As Boolean)
    If Not Me.disposed Then
        If disposing Then
            ' Insert code to free managed resources.
        End If
        ' Insert code to free unmanaged resources.
    End If
    MyBase.Dispose(disposing)
End Sub

Uma classe derivada não deve substituir Dispose e Finalize métodos. Quando esses métodos são chamados de uma instância da classe derivada, implementação desses métodos da classe base chama substituir a classe derivada do Dispose(disposing) método.

Visualização

O diagrama a seguir mostra os métodos que são herdados e quais métodos são substituídos na classe derivada.

When this DisposeFinalize pattern is followed, the resources of the derived class and base class are correctly disposed.A diagrama a seguir mostra quais métodos chamados quando as classes são descartadas e finalizadas.

Lixo coleção e o destruidor de finalização

The .NET Framework usa o referência de rastreamento coleta de lixo sistema periodicamente versão recursos não utilizados.Visual Basic 6.0 e versões anteriores usado um sistema diferente chamado Contagem de referência para gerenciar os recursos.Embora os dois sistemas executam a mesma função automaticamente, existem algumas diferenças importantes.

O CLR periodicamente destrói objetos quando o sistema determina que esses objetos não são mais necessários.Os objetos são liberados mais rapidamente quando recursos do sistema estão na fonte de curto e com menos freqüência, caso contrário.O atraso entre quando um objeto perde o escopo e quando o CLR libera significa que, ao contrário com objetos no Visual Basic 6.0 e versões anteriores, você não pode determinar exatamente quando o objeto será destruído.Nessa situação, os objetos são considerados ter tempo de vida não determinístico.Na maioria dos casos, tempo de vida não-determinístico não altera sistema autônomo escrever aplicativos, desde que você se lembrar de que o Finalize destrutor não pode executar imediatamente quando um objeto perde o escopo.

Outra diferença entre os sistemas de coleta de lixo envolve o uso de Nothing. Para tirar proveito de contagem no Visual Basic 6.0 e versões anteriores de referência, programadores atribuídos às vezes, Nothing a variáveis de objeto para versão as referências essas variáveis mantido. Se a variável considerada a última referência ao objeto, os recursos do objeto foram disponibilizados imediatamente.Nas versões posteriores do Visual Basic, apesar pode haver casos em que este procedimento é importante ainda, de executá-lo nunca causa o objeto referenciado versão imediatamente seus recursos.Para liberar recursos imediatamente, use Dispose método, se disponível. A única vez que você deve conjunto uma variável para Nothing é quando sua time de vida longa relativo para o time do coletor de lixo para detectar objetos órfãos.

Consulte também

Tarefas

Como: Implementar a Dispose Finalize padrão (Visual Basic)

Conceitos

Inicialização e de término de componentes

Finalize métodos and Destructors

Referência

Usando Construtores e Destrutores

Novo (Visual Basic)

Dispose

Nada (Visual Basic)

Outros recursos

Alterações na Linguagem para Usuários do Visual Basic 6.0