C# - Conceitos : Construtor (revisitado)

C# - Conceitos : Constructor (revisitado) - IV

Hoje vamos rever um conceito muito importante na linguagem C#: O Construtor.

Continuando a terceira parte do artigo vamos apresentar outros conceitos importantes sobre construtores.

Até o momento vimos que os construtores são usados para atribuir valores a membros da classe.

Será que existe um conceito oposto ao conceito de Construtor na linguagem C# ?

Sim, existe, são os Destructors ou finalizadores.

Nota: Não confunda Deconstructors com Destructors, os conceitos são bem diferentes.

Desctructors

Desctructors ou Finalizadores na linguagem C# são métodos dentro da classe usados para destruir instâncias dessa classe quando não são mais necessários.

São utilizados para realizar a limpeza do ambiente quando a instância da classe esta sendo coletada pelo coletor de lixo (garbage collector).

O programador não tem controle sobre quando o finalizador será chamado, pois isso é determinado pelo coletor de lixo que verifica se há objetos que não estão mais sendo usados pelo aplicativo. Se considerar um objeto elegível para finalização, ele chama o finalizador (se houver) e recupera a memória usada para armazenar o objeto.

Assim, uma variável de instância ou um objeto é elegível para destruição quando não estiver mais acessível , e, quando o objeto for elegível para finalização, o coletor de lixo executa o método Finalize do objeto.

A seguir algumas características de um Desctructor:

Um destruidor é exclusivo de sua classe, ou seja, não pode haver mais de um destruidor em uma classe;
Um destruidor não tem tipo de retorno e tem exatamente o mesmo nome que o nome da classe;
Distingue-se de um construtor por causa do símbolo (~) prefixado em seu nome;
Um destruidor não aceita nenhum parâmetro e modificador;
Não pode ser definido em Structs. É usado apenas com classes;
Não pode ser sobrecarregado ou herdado;
É chamado quando o programa sai;
Internamente, o Destructor chama o método Finalize na classe base do objeto;

Exemplo de código usando um Destructor:

   class DestructorDemo
    {
        // codigo
        // Destructor
        ~DestructorDemo()
        {
            // código
        }

Podemos implementar um Destructor ou Finalizador como uma definição do corpo de expressão:

    public class Exemplo
    {
          public override string ToString() => GetType().Name;

        ~Exemplo() => Console.WriteLine($"O destructor {ToString()} esta em execução.");
    }

Como internamente o Destructor chama implicitamente o método Finalize() da classe base do objeto, uma chamada ao finalizador pode ser descrita assim:

    protected override void Finalize()
    {
        try
        {
            //instrução de limpeza
        }
        finally
        {
            base.Finalize();
        }
    }

Nos aplicativos .NET Framework (mas não nos aplicativos .NET Core), os finalizadores também são chamados quando o programa é encerrado.

Finalizadores vazios não devem ser usados.

Quando uma classe contém um finalizador, uma entrada é criada na fila Finalize; e quando o finalizador é chamado, o coletor de lixo é chamado para processar a fila. Assim, um finalizador vazio apenas causa uma perda desnecessária de desempenho.

"Com o ouvir dos meus ouvidos ouvi, mas agora te vêem os meus olhos.
Por isso me abomino e me arrependo no pó e na cinza. "
Jó 42:5,6

Referências:

José Carlos Macoratti