Vida útil de objeto: Como os objetos são criados e destruídos (Visual Basic)

Artigo
08/08/2011

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 de inicialização comuns incluem a abertura de arquivos, conectar-se a bancos de dados e ler os valores das chaves do registro. A inicialização de novos objetos usando os procedimentos chamados de controles de Visual Basic construtores (métodos especiais que permitem o controle de inicialização).

Depois de um objeto sai do escopo, ela foi lançada pelo Common Language Runtime (CLR). Visual Basic controla a versão recursos do sistema usando os procedimentos chamados destruidores. Juntos, construtores e destrutores suportam a criação de robusto e bibliotecas de classe de previsível.

Using Constructors and Destructors

Constructors and destructors control the creation and destruction of objects. O Sub New e Sub Finalize Visual Basic procedimentos inicializar e destruir objetos; eles substituir o Class_Initialize e Class_Terminate métodos usados no Visual Basic versões 6.0 e anteriores.

Novosub

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

To create a constructor for a class, create a procedure named Sub New anywhere in the class definition. To create a parameterized constructor, specify the names and data types of arguments to Sub New just as you would specify arguments for any other procedure, as in the following code:

Sub New(ByVal s As String)

Constructors are frequently overloaded, as in the following code:

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

When you define a class derived from another class, the first line of a constructor must be a call to the constructor of the base class, unless the base class has an accessible constructor that takes no parameters. A call to the base class that contains the above constructor, for example, would be MyBase.New(s). Otherwise, MyBase.New is optional, and the Visual Basic runtime calls it implicitly.

Depois de escrever o código para chamar o pai de objetodo construtor, você pode adicionar qualquer código de inicialização de adicionais para o Sub New procedimento. Sub Newpode aceitar argumentos quando chamado como um construtorde parametrizadas. These parameters are passed from the procedure calling the constructor, for example, Dim AnObject As New ThisClass(X).

Sub Finalize

Antes de soltar objetos, o CLR chama automaticamente o Finalizeométodo para objetos que definem um Sub Finalizeprocedimento. O Finalize método pode conter código que precisa ser executar antes de um objeto é destruído, como, por exemplo, código fecham arquivos e salvar informações de estado. Há uma penalidade de desempenho de leve para a execução de Sub Finalize, portanto, você deve definir um Sub Finalize método somente quando você precisa versão objetos explicitamente.

Observação
O coletor de lixo no CLR não (e não pode) descartar objetos não gerenciados, os objetos que o sistema operacional executa diretamente, fora doambientedo CLR. Isso ocorre porque os diferentes objetos não gerenciados devem ser descartados de maneiras diferentes. Essas informações não são diretamente associadas com o objetonã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 coletor de lixo no CLR não (e não pode) descartar objetos não gerenciados, os objetos que o sistema operacional executa diretamente, fora doambientedo CLR. Isso ocorre porque os diferentes objetos não gerenciados devem ser descartados de maneiras diferentes. Essas informações não são diretamente associadas com o objetonã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 é protegido método 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 explicitamente deve chamar Finalize de fora de uma derivada classedo Finalize de implementação.

Ao contrário de Class_Terminate, que é executado como um objeto é definida 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 imediatamente versão recursos.

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

How New and Finalize Methods Work in a Class Hierarchy

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. A New constructor can be used to open files, connect to databases, initialize variables, and take care of any other tasks that need to be done before an object can be used.

When an instance of a derived class is created, the Sub New constructor of the base class executes first, followed by constructors in derived classes. This happens because the first line of code in a Sub New constructor uses the syntax MyBase.New()to call the constructor of the class immediately above itself in the class hierarchy. The Sub New constructor is then called for each class in the class hierarchy until the constructor for the base class is reached. At that point, the code in the constructor for the base class executes, followed by the code in each constructor in all derived classes and the code in the most derived classes is executed last.

Construtores e herança

When an object is no longer needed, the CLR calls the Finalize method for that object before freeing its memory. The Finalize method is called a destructor because it performs cleanup tasks, such as saving state information, closing files and connections to databases, and other tasks that must be done before releasing the object.

Construtores e herança 2

Interface IDisposable

Instâncias da classe geralmente controlam os recursos não gerenciado pelo CLR, como, por exemplo, as alças de Windows e conexões de banco de dados . Esses recursos devem ser descartados na Finalizeomé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 a liberar mais memória. This means that the resources may not be released until long after the object goes out of scope.

Para complementar a coleçãode lixo, suas classes podem fornecer um mecanismo para gerenciar ativamente os recursos do sistema se eles implementam 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 versão recursos imediatamente e realizar tarefas como, por exemplo, fechando arquivos e conexões de banco de dados . Ao contrário do Finalize destruidor, o Dispose método não é chamado automaticamente. Clientes de uma classe devem chamar explicitamente Dispose quando 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 da Dispose que libera todos os recursos da classe. Este método deve ser chamado 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 da Finalizeométodo que contém apenas o seguinte código:

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

A derivação de uma classe que implementa IDisposable

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

Coleta de lixo e o destruidor de finalizar

O .NET Framework usa o referênciarastreamento lixo coleção sistema periodicamente a 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. Although both systems perform the same function automatically, there are a few important differences.

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, diferentemente com objetos no Visual Basic 6.0 e versões anteriores, você não pode determinar exatamente quando o objeto será destruído. Em uma situação assim, os objetos são considerados ter de determinística não- tempo de vida. Na maioria dos casos, de determinística não- tempo de vida não altera como escrever aplicativos, desde que você se lembrar de que o Finalize destruidor talvez não imediatamente executar quando um objeto perde o escopo.

Outra diferença entre os sistemas decoleção de lixo - envolve o uso de Nothing. Para aproveitar a contagem no Visual Basic 6.0 e versões anteriores de referência, os programadores atribuído às vezes, Nothing variáveis de objeto para versão as referências essas variáveis ocupou. If the variable held the last reference to the object, the object's resources were released immediately. In later versions of Visual Basic, while there may be cases in which this procedure is still valuable, performing it never causes the referenced object to release its resources immediately. Para versão recursos imediatamente, use o objetodo Dispose método, se disponível. A única vez que você deve definir uma variável de Nothing é quando a sua tempo de vida longa em relação ao momento em que o coletor de lixo leva para detectar objetos órfãos.