Tempo de vida do objeto: Como os objetos são criados e destruído (Visual Basic)

Uma instância de uma classe, um objeto, é criada usando o New palavra-chave.Tarefas de inicialização normalmente devem ser executadas em novos objetos antes de serem usadas.Tarefas de inicialização comuns incluem a abertura de arquivos, conectar-se a bancos de dados e ler os valores das 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).

Depois que um objeto sai do escopo, ela é lançada pelo common language runtime (CLR).Visual Basic controla o lançamento dos recursos do sistema usando os procedimentos chamados destruidores.Juntos, construtores e destrutores suporte à criação de bibliotecas de classes robusta e previsível.

Usando Construtores e Destrutores

Construtores e destrutores controlam a criação e a destruição de objetos.O Sub New e Sub Finalize Visual Basic procedimentos inicializar e destruir objetos; eles substituem o Class_Initialize e Class_Terminate métodos usados no Visual Basic versões 6.0 e versões anteriores.

Sub New

O Sub New construtor pode ser executado apenas uma vez que uma classe é criada.Não é possível chamar explicitamente em qualquer local diferente na primeira linha do código de outro construtor partir da mesma classe ou de uma classe derivada.Além disso, o código do Sub New método é sempre executado antes de qualquer outro código em uma classe.Visual Basic 2005e versões posteriores criam implicitamente uma Sub New construtor em tempo de execução se você não definir explicitamente um Sub New procedimento para uma classe.

Para criar um construtor para uma classe, crie um procedimento chamado Sub New em qualquer lugar na definição da classe.Para criar um construtor com parâmetros, especifique os nomes e tipos de dados dos argumentos para Sub New exatamente como você faria para qualquer outro procedimento, como no código a seguir:

Sub New(ByVal s As String)

Os construtores são frequentemente sobrecarregados, como no código a seguir:

Sub New(ByVal s As String, i As Integer)

Quando você define uma classe derivada de outra classe, a primeira linha de um construtor deve ser uma chamada para o construtor da classe base, a menos que a classe base tenha um construtor acessível que não recebe parâmetros.Uma chamada para a classe base que contém o construtor acima, por exemplo, seria MyBase.New(s).Caso contrário, MyBase.New é opcional, e o tempo de execução Visual Basic chama implicitamente.

Depois de escrever o código para chamar o construtor do objeto pai, você pode adicionar qualquer código de inicialização adicional para o Sub New procedimento.Sub Newpode aceitar argumentos quando chamado como um construtor parametrizado.Esses parâmetros são passados do procedimento que está chamando o construtor, por exemplo, Dim AnObject As New ThisClass(X).

Sub Finalize

Antes de soltar objetos, o CLR chama automaticamente o Finalize método para objetos que definem um Sub Finalize procedimento.O Finalize o método pode conter código que precisa ser executado antes de um objeto é destruído, tais como códigos fecham arquivos e salvar informações de estado.Existe uma penalidade de desempenho leve para a execução de Sub Finalize, portanto, você deve definir um Sub Finalize método somente quando você precisar liberar objetos explicitamente.

Observação

O coletor de lixo do CLR não pode (e não pode) dispose de objetos não gerenciados, os objetos que o sistema operacional é executado diretamente, fora do ambiente do CLR.Isso ocorre porque os diferentes objetos não gerenciados devem ser descartados de maneiras diferentes.Essa informação não está diretamente associada com o 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.

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

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

Observação
A Finalize destruidor não deve lançar exceções, pois eles não podem ser manipulados pelo aplicativo e podem fazer com que o aplicativo seja finalizado.

Como os métodos New e Finalizes trabalham em uma hierarquia de classes

Sempre que uma instância de uma classe é criada, o common language runtime (CLR) tenta executar um procedimento denominado New, se ele existir nesse objeto.Newé um tipo de procedimento chamado um constructor que é usado para inicializar novos objetos antes de qualquer outro código em um objeto é executado.Um construtor New pode ser usado para abrir arquivos, conectar-se a bancos de dados, inicializar variáveis e cuidar de quaisquer outras tarefas que precisam ser feita antes que um objeto possa ser usado.

Quando uma instância de uma classe derivada é criada, o construtor Sub New da classe base executa primeiro, seguido pelos construtores em classes derivadas.Isso acontece porque a primeira linha de código em um construtor Sub New usa a sintaxe MyBase.New() para chamar o construtor da classe imediatamente acima de si próprio na hierarquia de classe.Em seguida, o construtor Sub New é chamado para cada classe na hierarquia de classe até que o construtor para a classe base seja alcançado.Nesse ponto, o código no construtor para a classe base executa, seguido do código em cada construtor em todas as classes derivadas e o código na classe mais derivada é executado por último.

Quando um objeto não for mais necessário, o CLR chama o método Finalize para o objeto antes de liberar sua memória.O método Finalize é denominado um destructor porque ele realiza tarefas de limpeza, como salvar informações do estado, fechar arquivos e conexões com bancos de dados e outras tarefas que devem ser executadas antes de liberar o objeto.

Interface IDisposable

Instâncias da classe geralmente controlam os recursos não gerenciados pelo CLR, como conexões de banco de dados e alças de Windows.Esses recursos devem ser descartados de na 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 somente quando o CLR requer mais memória livre.Isto significa que os recursos podem não ser liberados até muito tempo depois que o objeto sai do escopo.

Para complementar a coleta de lixo, suas classes podem fornecer um mecanismo para gerenciar ativamente os recursos do sistema se implementarem o IDisposable interface.IDisposabletem um método, Dispose, os clientes que devem chamar quando concluir a utilização de um objeto.Você pode usar o Dispose método para liberar recursos e executar tarefas como fechar arquivos imediatamente e conexões de banco de dados.Ao contrário do Finalize destruidor, o Dispose método não é chamado automaticamente.Os clientes de uma classe devem chamar explicitamente Dispose quando você deseja liberar imediatamente os 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 de Dispose que libera os recursos da classe.Este 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 substituição da Finalize método que contém somente o código a seguir:

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

A derivação de uma classe que implementa IDisposable

Uma classe que deriva de uma classe base que implementa o IDisposable interface não precisa substituir qualquer um dos métodos base, a menos que ele usa os recursos adicionais que precisam ser eliminado.Nessa situação, a classe derivada deve substituir a classe base Dispose(disposing) método para descartar os recursos da classe derivada.Essa substituição deve chamar a classe base 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 a classe base Dispose e Finalize métodos.Quando esses métodos são chamados de uma instância da classe derivada, a implementação da classe base desses métodos chame a substituição da classe derivada da Dispose(disposing) método.

Coleta de lixo e o destruidor de finalizar

O .NET Framework usa o coleta de lixo de rastreamento de referência sistema periodicamente liberar 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 ambos os sistemas executem a mesma função automaticamente, existem algumas diferenças importantes.

Periodicamente, o CLR destrói objetos quando o sistema determina que esses objetos não são mais necessários.Quando os recursos do sistema estão na fonte de curto e com menos freqüência, caso contrário, os objetos são liberados mais rapidamente.O atraso entre quando um objeto perde o escopo e quando o CLR libera significa que, ao contrário de objetos no Visual Basic 6.0 e versões anteriores, você não pode determinar exatamente quando o objeto será destruído.Nesses casos, os objetos são considerados ter o tempo de vida não-determinística.Na maioria dos casos, o tempo de vida não-determinístico não altera como escrever aplicativos, desde que você se lembrar de que o Finalize destruidor 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, os programadores atribuído às vezes, Nothing ocupou essas variáveis de variáveis para liberar as referências de objeto.Se a variável realizada a última referência ao objeto, o objeto de recursos foram liberados imediatamenteEm versões posteriores do Visual Basic, enquanto que pode haver casos em que este procedimento ainda seja valioso, desenvolvê-lo  nunca faz com que o objeto referenciado para liberar seus recursos seja de fato liberado imediatamente.Para liberar recursos imediatamente, use o objeto Dispose método, se disponível.A única vez que você deve definir uma variável para Nothing é quando a sua vida útil é muito tempo relativo para o tempo do coletor de lixo para detectar objetos órfãos.

Consulte também

Referência

Operador New (Visual Basic)

Dispose

Nada (Visual Basic)

Conceitos

Inicialização e término de componentes

Finalizar métodos e destruidores