10 Dicas Basicas de Arquitetura de Código : 1 - Aproveitando os Benefícios da Virtualização
Tags: architecture, beginners, programming, dotnet
Published: 2023-06-06 20:30:35


![Bertuzzi no PC](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/suw4e3caj75kx3vi88ml.png)

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!


![Bertuzzi com Métodos Virtuais](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w6hffqavpkziwlas2jae.png)

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 :


```csharp
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)](https://devshow.com.br/episode/devshow-22-solid-ocp/)
2 - [SOLID: OCP - Open/Closed Principle (Princípio do Aberto/Fechado)](https://www.youtube.com/watch?v=UlSNpWFTU3Q)

Espero ter ajudado!

Aquele abraço!