10 Dicas Basicas de Arquitetura de Código : 1 - Aproveitando os Benefícios da Virtualização

Fala galera,

tudo beleza?

Vou começar uma serie de artigos de dicas basicas para desenvolvedores com conceitos simples e uteis de Arquitetura com .net (Mesmo que você consiga aplicar para sua linguagem :) ).

Hoje vamos falar de Métodos Virtuais ! Bora!

Por mais que alguns escrevam artigos dizendo o contrario, a arquitetura de software desempenha um papel fundamental no desenvolvimento de aplicativos eficientes e escaláveis.

Uma das abordagens mais poderosas é a utilização de métodos virtuais. Essa técnica oferece uma série de benefícios que vão desde a extensibilidade até a facilidade de manutenção do código.

O que são métodos virtuais?

Um método virtual é aquele que pode ser sobrescrito em uma classe derivada, permitindo que seu comportamento seja modificado para atender às necessidades específicas dessa classe. Essa flexibilidade é alcançada através do uso da palavra-chave virtual na declaração do método na classe base e da palavra-chave override na declaração do método na classe derivada.

E Quais as vantagens?

- Extensibilidade: Ao utilizar métodos virtuais, é possível estender a funcionalidade de uma classe base através da criação de classes derivadas que substituem o comportamento dos métodos virtuais. Isso permite adicionar novos recursos ou personalizar o comportamento existente sem modificar a classe base, mantendo assim a integridade do código.

- Polimorfismo: O polimorfismo é um dos princípios fundamentais da programação orientada a objetos, e os métodos virtuais são uma ferramenta essencial para sua implementação. Com métodos virtuais, é possível tratar objetos derivados como objetos da classe base, facilitando o uso de herança e permitindo que diferentes implementações de um método sejam invocadas com base no tipo de objeto em tempo de execução.

- Manutenção simplificada: As modificações em um método na classe base refletem-se automaticamente em todas as classes derivadas que o sobrescrevem. Isso simplifica a manutenção do código, uma vez que as alterações são centralizadas e propagadas para todas as partes relevantes do sistema.

Vamos ver um exemplo bem facil para isso :

public class Pessoa
{
    public virtual void MeuCabelo()
    {
        Console.WriteLine("Meu Cabelo Esta grande");
    }
}

public class Bertuzzi : Pessoa
{

}

public class Andre : Pessoa
{
    public override void MeuCabelo()
    {
        Console.WriteLine("Meu Cabelo Esta Sumindo.");
    }
}

public class Ewerton : Pessoa
{
    public override void MeuCabelo()
    {
        Console.WriteLine("Meu Cabelo Sumiu.");
    }
}

class Program
{
    static void Main(string[] args)
    {
        var bertuzzi = new Bertuzzi();
        var andre = new Andre();
        var ewerton = new Ewerton();

        bertuzzi.MeuCabelo(); // Saída: "Meu Cabelo Esta grande."
        andre.MeuCabelo();   // Saída: "Meu Cabelo Esta Sumindo."
        ewerton.MeuCabelo(); // Saída: "Meu Cabelo Sumiu."
    }
}

Neste exemplo, a classe base Pessoal possui um método virtual MeuCabelo() que exibe uma frase genérico. As classes derivadas Andre e Ewerton substituem esse método para exibir suas proprias fases genericas. Ao instanciar os objetos e chamar o método MeuCabelo(), o comportamento apropriado é invocado com base no tipo de objeto em tempo de execução.

Como a classe Bertuzzi não sobrescreve o método, a mesma possui o comportamento do método Virtual.

Simples não? Com essa implementação simples muitos softwares que as vezes precisam de comportamentos especificos podem ser implementados de maneira facil ;).

Caso queira saber mais sobre o assunto abordado no principio de OCP (Open-Closed Principle). Vou deixar esses dois links que eu recomendo muito :

1 - DEVSHOW #22 – SOLID (OCP)
2 - SOLID: OCP - Open/Closed Principle (Princípio do Aberto/Fechado)

Espero ter ajudado!

Aquele abraço!