Introdução

Ser programador é muito além de saber resolver problemas complexos e entender sobre lógica, testes e análise complexas. Há conjuntos de princípios teóricos, testados e comprovados que, quando aplicados em projetos, refinam a arte do desenvolvimento de software. Esses princípios, criados e estudados por engenheiros de softwares consistem em abordagem que norteiam a escrita de um código limpo, fácil de depurar e entender.

Em poucas palavras, podemos dizer que os princípios da engenharia de software buscam soluções que facilitam a modificação de um código existente no futuro, sem acoplamento excessivo e sem problemas.

O que e DRY

Quando estamos desenvolvendo uma aplicação, implementar novas funcionalidades sem planejamento prévio arquitetado resulta em diversos impactos no sistema, o mais comum é a repetição de código. Em algum momento da sua vida você “já se pegou” navegando por um projeto, mudando várias classes, arquivos ou páginas durante alguma manutenção para consertar apenas um único detalhe de uma nova implementação.

Sabendo disso Andy Hunt e Dave Thomas conceituaram em seu livro The Pragmatic Programmer o conceito de Don’t Repeat Yourself (DRY), esse conceito virou um dos princípios mais fundamentais de todos.

O DRY propõe que cada funcionalidade em um projeto deve ser representada apenas uma vez. A repetição é desperdício em qualquer sistema inteligente, seja em modelo de dados, desenvolvimento de códigos, etc. Quanto mais simples, enxute e reaproveitado o código for, melhor!

Implementação do DRY

Existem diversas formas de implementar esse princípio, não existe nenhum sistema específico para a sua implementação, pode ser aplicado em uma simples aplicação no console ou até uma complexa API.

Além disso as soluções desse problema também pode variar de simples para as mais complexas. Encapsulamentos básicos, abstrair toda a funcionalidade em uma classe base para que as classes derivadas herdem dela.

Vale lembrar que nem toda implementação usando esse princípio pode estar correta, é sempre importante usar o bom senso, já que quando ele é mal aplicado aumenta o acoplamento (dependência entre as classes) e dificulta a leitura e entendimento do código. Por isso, não é suficiente apenas aplicar o princípio DRY o tempo todo, mas deve-se levar em conta todo o contexto do sistema.

Existem diversas formas de implementar o princípio DRY, e ao desconfiar que está usando um código semelhante podemos refatorar o código:

• Classe privada reutilizável
• Classe pública utiliátia (class Helper)
• Usando uma Interface
• Usando conceitos de Generics
• Métodos

Exemplos

1. Um caso simples de modelagem é a criação de uma Entidade Pessoa que possuem alguns atributos bases Nome, Idade e PaisOrigem. A partir dessa Entidade base podemos criar duas outras Entidades Jogador e Tecnico que herdarão esses atributos (além dos seus atributos específicos). Então, ao invés de termos o Nome, Idade e PaisOrigem repetindo nos três modelos de dados, reaproveitamos o código.

2. Um outro caso mais simples e direto é aquela situação que repetimos linhas de códigos idênticas que realizam a mesma tarefa.
   

     static void ItemSelecionado(string item)
           {
               switch(item)
               {
                   case "1":
                       **Console.Clear();**
                       //Operacao1();
                       break;
                   case "2":
                       **Console.Clear();**
                       //Operacao2();
                       break;
                   case "3":
                       **Console.Clear();**
                       //Operacao3();
                       break;
                   case "4":
                       **Console.Clear();**
                       //Operacao4();
                       break;
                   case "5":
                       **Console.Clear();**
                       return;
                   default:
                       Console.Clear();
                       Console.WriteLine("Item inválido");
                       break;
               }
           }
   
   

```csharp
    static void ItemSelecionado(string item)
        {
            **Console.Clear();**
            switch (item)
            {
                case "1":
                    //Operacao1();
                    break;
                case "2":
                    //Operacao2();
                    break;
                case "3":
                    //Operacao3();
                    break;
                case "4":
                    //Operacao4();
                    break;
                case "5":
                    return;
                default:
                    Console.WriteLine("Item inválido");
                    break;
            }
        }
```