Inicialização e término de componentes

O componente é inicializado pelo construtor (SubNew no Visual Basic) e destruído pelo destrutor (SubFinalizeno Visual Basic). O construtor do componente é chamado quando uma instância do componente é criada; o construtor não pode ser chamado depois de isso. O destrutor é chamado logo antes que o componente será destruído pela coleta de lixo e sua memória é recuperada.

Observação do Visual Basic
Em versões anteriores do Visual Basic, os eventos de Initialize e de Terminate serviram a mesma finalidade que o construtor e o destrutor.

Coleta de lixo de espera

O common language runtime chama o destrutor do seu componente depois que coleta de lixo determina que o componente não pode mais ser alcançado por qualquer código em execução. Isso acontece se todas as referências para o componente foi liberadas, ou se as únicas referências ao seu componente são mantidas pelos objetos que estão isolados mesma forma de todo o código em execução — por exemplo, no caso de referências circulares.

Porque pode haver um atraso entre o momento em que um usuário terminou com seu componente e o momento em que o destrutor é chamado, uma etapa adicional é apresentada no tempo de vida de componentes do.NET Framework: Se o componente obtém os recursos do sistema, como conexões de banco de dados ou trata os objetos do sistema do windows, você deve implementar a interface de IDisposable , e fornece um método de Dispose para que os usuários do seu componente pode escolher quando liberar os recursos.

Ciclo de vida de um componente

Type initialization: Quando a primeira instância do componente é criada, o primeiro código que executa é qualquer código de inicialização compartilhado. Uma referência a qualquer membro compartilhado também fará com que o construtor compartilhado é executado. Isso inclui todos os campos compartilhados (variáveis de membros) que é inicializado, e o construtor compartilhado (SharedSubNew) se existe. Em o código a seguir, uma fonte de referência é criada para a classe inteira.

Dica

A palavra-chave C# que corresponde a Shared é static, que não deve ser confundido com a palavra-chave de Static no Visual Basic.

Public Class ADrawing
Shared ReadOnly ReferenceFont As New Font("TimesNewRoman", 14)
' Shared constructor does not overload other constructors.
Shared Sub New()
   ' There is no call to the base class's shared constructor.
   ' Insert code to initialize the shared data.
End Sub
End Class

class ADrawing
{
   static Font m_referenceFont = new Font("TimesNewRoman", 14);
   // Simply add the static keyword to create a static constructor.
   // Static constructors do not have any parameters.
   static ADrawing()
   {
      // There is no call to the base class's static constructor.
      // Code to initialize the font here.
   }
}

Dica

A classe de inicialização pode ocorrer se nenhuma instância do componente é criada.Por exemplo, uma classe de abstract (MustInherit) com funções de membro compartilhado será inicializada e essas funções estarão disponíveis para uso do aplicativo, mesmo que nenhuma instância da classe é criada.

1. Instance initialization: Quando uma instância do componente é criada, os membros de dados que têm o código de inicialização são inicializados, e o construtor que apropriado a sobrecarga é executada. O código a seguir inicializa um campo particular e define dois construtores, um para ser chamado se não houver nenhum parâmetro, e o outro para ser chamado se o usuário especifica parâmetros.

   Class AShape
      Private answer As Integer = 42
      Public Sub New()
         ' Call another constructor with default initialization values.
         MyClass.New(System.Drawing.Color.Red, 5280, DefinedSizes.Large)
      End Sub
      Public Overloads Sub New(myColor As Color, myLength As Integer, _
               Size As DefinedSizes)
         ' Insert code to initialize the class.
      End Sub
      ' Defines the DefinedSizes enum
      Public Enum DefinedSizes
         Large
         Small
      End Enum
   End Class
   

   class AShape
   {
      private int m_answer = 42;
      // Forward to another constructor.
      public AShape() 
      : this(System.Drawing.Color.Red, 5280, DefinedSizes.Large)
      {
         // Additional initialization goes here.
      }
   
      public AShape(Color color, int length, DefinedSizes size)
      {
         // Code to initialize the class goes here.
      }
      // Defines the DefinedSizes enum
      public enum DefinedSizes
      {
         Large,
         Small
      }
   }
   

2. Disposing of resources: Se o componente implementa a interface de IDisposable , deve fornecer um método de Dispose , que o cliente deve chamar quando tiver terminado usando o componente. Observe que qualquer componente que herda de Component já tem uma implementação padrão de Dispose, que pode ser substituída para fornecer código adicional de limpeza. Em o método de Dispose , o componente libera os recursos do sistema pode ter atribuído, referências de versões a outros objetos, e se torna inutilizável. Também pode haver as instâncias onde for apropriado para seu componente chamar seu próprio método de Dispose . O código a seguir descartar um objeto dependente que tem um método de Dispose .

   ' Assumes that the class implements IDisposable
   Public Sub Dispose() Implements IDisposable.Dispose
      myWidget.Dispose
      myWidget = Nothing
      ' Insert additional code.
   End Sub
   

   // Assumes that the class implements IDisposable
   public void IDisposable.Dispose()
   {
      mywidget.Dispose();
      mywidget = null;
      // Dispose of remaining objects.
   }
   
   

   Depois de você chamar Dispose, o cliente deve liberar todas as referências alocado para o componente, de modo que coleta de lixo possa recuperar memória do componente.

3. Instance destruction: Quando a coleta de lixo detecta que não há nenhuma referência alocado para o componente, o tempo de execução chama o destrutor do seu componente (Finalizeno Visual Basic) e libera memória. Você deve substituir o método de Finalize da classe base (Visual Basic) ou implementar um destrutor (para visual C#) para implementar seu próprio código de limpeza, mas sempre incluir uma chamada para o destrutor ou método de Finalize da classe base.

   Protected Overrides Sub Finalize()
      m_Gadget = Nothing
      m_Gear = Nothing
      MyBase.Finalize()
   End Sub
   

   // In C#, a destructor is used instead of a Finalize method.
   ~ThisClass()
   {
      m_gadget = null;
      m_gear = null;
      // The base class finalizer is called automatically
   }
   

Quando você deve implementar um método de descarte?

Se o componente herda de Component, uma implementação padrão de Dispose é fornecida. Essa implementação pode ser substituída para fornecer código personalizado de limpeza. Se você estiver criando seu componente criando uma implementação personalizada de IComponent, você deve implementar IDisposable para fornecer um método de Dispose para o componente.

O componente precisa de um método de Dispose se atribui objetos do sistema, conexões de banco de dados, ou outros recursos escassos que devem ser liberados para que um usuário tiver terminado com o componente.

Você também deve implementar um método de Dispose se o componente contém referências a outros objetos que possuem métodos de Dispose .

Por que implementam descarte?

Dependendo da atividade do sistema, um intervalo imprevisível pode passar entre o momento conclusão de um usuário usando o componente e coleta de lixo detecta de tempo que o código do componente é inacessível. Se você não fornecer um método de Dispose , o componente continuará a manter seus recursos durante esse intervalo.

Um cenário pior

Imagine um componente de servidor que use uma conexão de banco de dados e não tem um método de Dispose . Em um servidor com uma grande quantidade de memória, você pode criar e liberar muitas instâncias do componente não ter muito impacto na memória livre. Em esse caso, coleta de lixo não pode destruir componentes por algum tempo após as referências a eles são liberadas.

Se houver, todas as conexões de banco de dados disponíveis podem ser vinculados anterior por componentes que eles tivessem sido liberados mas não destruídos. Mesmo que o servidor não tem nenhuma falta de memória, pode ser incapaz de responder às solicitações de usuário.

Consulte também

Tarefas

Como criar e configurar componentes no modo de design

Referência

Dispose

Finalize

Conceitos

Características das classes de componentes

Mudanças na criação de instâncias de componentes no Visual Basic