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:

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 vemos 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 :

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

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

Quer aprender a criar aplicações Web Dinâmicas usando a ASP .NET MVC 5 ?


  Gostou
?   Compartilhe no Facebook   Compartilhe no Twitter

 

Referências:


José Carlos Macoratti