DRY - Don't Repeat Yourself (A repetição de código é a raiz de todo o mal...)

DRY - Don't Repeat Yourself - Não se repita

Neste artigo eu vou apresentar o princípio definido pelo acrônimo
DRY - Don't Repeat YourSelf, ou : 'Não se repita'

O princípio DRY, 'Não se Repita', é um importante princípio que procura reduzir a duplicação de código e os problemas oriundos dessa prática.

A definição formal desse princípio diz :

"Cada parte do conhecimento deve ter uma representação única, não ambígua e definitiva dentro do sistema."

Extraindo o cerne do princípio : 'Não escreva código duplicado' (embora o princípio seja mais que isso)

O código duplicado cria os seguintes problemas:

A impossibilidade de garantir que todas as instâncias repetidas serão modificadas quando uma alteração for requerida; (aumenta a chance de bugs)
Requer o gerenciamento de memória e ciclos de runtime para processar blocos de códigos idênticos; (impacta o desempenho da aplicação)

O conceito está em conformidade com o princípio Open/Closed ou Princípio Aberto/Fechado, através da criação de código reutilizável que pode ser consumido por mais de uma entidade.

Talvez o exemplo mais simples e claro seja aquele onde temos linhas de código idênticas que realizam a mesma tarefa repetida várias vezes em um trecho de código sem necessidade.

No exemplo abaixo vamos remover 5 linhas de código otimizando o código:

        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;
            }
        }

     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;
            }
        }

Dessa forma, quando você estiver desenvolvendo, e, desconfiar que está usando um código semelhante (duplicado) mais de uma vez, você deve refatorar o código :

Em uma classe privada reutilizável;
Em uma classe pública utilitária (classe Helper);
Em uma estrutura;
Em uma interface;
Ou em um método;

Se você estiver passando os mesmos parâmetros, primitivos ou tipos de objetos, você deve refatorá-los em objetos DTOs (Data Transfer Objects) passando-os como um único objeto.

Exemplo:

CalcularPedido(double valorItem,int quantidadeItem, double impostoItem,double descontoItem,...)

CalcularPedido(Pedido pedido)

Nota: O uso dos DTOs esta em conformidade com a prática de encapsulamento de dados da orientação a objetos.

Use com bom senso

Esse princípio deve ser aplicado sempre com bom senso.

Pois quando ele é mal aplicado aumenta o acoplamento (a dependência entre as classes) e dificulta a leitura e entendimento do código.

Assim, não é suficiente apenas aplicar um princípio o tempo todo; deve-se levar em conta outros princípios e pesar seus valores relativos de acordo com a situação.

Exemplo de aplicação do princípio DRY que pode ser questionado:

public List<Employee> GetAllEmployees()
{
    using (Entities entities = new Entities())
    {
        return entities.Employees.ToList();
    }
}

public List<Job> GetAllJobs()
{
    using (Entities entities = new Entities())
    {
        return entities.Jobs.ToList();
    }
}

public List<Task> GetAllTasksOfTheJob(Job job)
{
    using (Entities entities = new Entities())
    {
        return entities.Tasks.Where(t => t.JobId == job.Id).ToList();
    }
}

public K UsingT<T,K>(Func<T,K> f) where T:IDisposable,new()
{
    using (T t = new T())
    {
        return f(t);
    }
}

public List<Employee> GetAllEmployees()
{
    return UsingT<Entities,List<Employee>>(e=>e.Employees.ToList());
}

public List<Job> GetAllJobs()
{
    return UsingT<Entities,List<Job>>(e=>e.Jobs.ToList());
}

public List<Task> GetAllTasksOfTheJob(Job job)
{
    return UsingT<Entities,List<Task>>(e=>e.Tasks.Where(t => t.JobId == job.Id).ToList());
}

É como diz o ditado popular: "Bom senso e canja de galinha não faz mal para ninguém..."

(Disse Jesus aos fariseus) Hipócritas, bem profetizou Isaías a vosso respeito, dizendo:
Este povo se aproxima de mim com a sua boca e me honra com os seus lábios, mas o seu coração está longe de mim.
Mas, em vão me adoram, ensinando doutrinas que são preceitos dos homens.
Mateus 15:7-9

Referências:

José Carlos Macoratti