10 Princípios Essenciais do Clean Code

Clean Code, ou código limpo, é uma abordagem e um conjunto de princípios e práticas que visam melhorar a qualidade e a legibilidade do código fonte de um software. O conceito foi introduzido pelo renomado autor e engenheiro de software Robert C. Martin, também conhecido como Uncle Bob.

Clean Code se concentra em tornar o código mais compreensível, fácil de manter, modificar e reutilizar. Ele enfatiza a clareza, simplicidade e expressividade do código, promovendo uma estrutura lógica, nomes significativos, funções e classes bem definidas, além de evitar duplicação e complexidade desnecessária.

Vamos explorar seus 10 princípios essenciais e fornecer exemplos práticos em C# para ilustrar cada um deles.

#1 Nomes significativos:

Escolha nomes descritivos e claros para classes, métodos, variáveis e parâmetros. Evite abreviações e siglas confusas. Por exemplo:

// Ruim
public void CalcImposto(decimal s)
{
    // código...
}

// Bom
public void CalcularImposto(decimal salario)
{
    // código...
}

#2 Funções pequenas e claras:

Mantenha suas funções curtas e focadas em uma única tarefa. Evite funções muito extensas e complexas. Por exemplo:

// Ruim
public void ProcessarDados()
{
    // código com várias responsabilidades...
}

// Bom
public void ObterDados()
{
    // código para obter os dados...
}

public void ProcessarDados()
{
    // código para processar os dados obtidos...
}

#3 Comentários relevantes:

Use comentários apenas quando necessário e para explicar o porquê de certas decisões ou para esclarecer trechos de código complexos. Evite comentários óbvios que repetem o que o código já diz. Por exemplo:

// Ruim
int idade = 18; // Define a idade como 18

// Bom
int idade = 18; // Idade mínima para acessar a funcionalidade X

#4 Evite duplicação:

Evite repetir código sem necessidade. Procure identificar padrões e abstraia-os em funções, classes ou bibliotecas reutilizáveis. Por exemplo:

// Ruim
public void CalcularAreaCirculo(float raio)
{
    float area = 3.14 * raio * raio;
    // código para exibir a área...
}

public void CalcularAreaRetangulo(float @base, float altura)
{
    float area = @base * altura;
    // código para exibir a área...
}

// Bom
public float CalcularAreaCirculo(float raio)
{
    return 3.14 * raio * raio;
}

public float CalcularAreaRetangulo(float @base, float altura)
{
    return @base * altura;
}

#5 Mantenha a consistência:

Siga um estilo de formatação consistente no seu código. Utilize as convenções da linguagem e padrões estabelecidos. Isso facilita a leitura e manutenção do código. Por exemplo:

// Ruim
public void Exemplo()
{
int numero = 10;
if(numero > 5)
{
Console.WriteLine("Maior que 5.");
}
else
{
Console.WriteLine("Menor que 5.");
}
}

// Bom
public void Exemplo()
{
    int numero = 10;
    if (numero > 5)
    {
        Console.WriteLine("Maior que 5.");
    }
    else
    {
        Console.WriteLine("Menor que 5.");
    }
}

#6 Limite de responsabilidade:

Evite que uma classe ou método tenha muitas responsabilidades. Separe as tarefas em unidades menores e coesas. Isso facilita a manutenção e reutilização do código. Por exemplo:

// Ruim
public class ProcessadorDePagamento
{
    public void ProcessarPagamento(Pedido pedido)
    {
        // código para processar o pagamento
        // código para atualizar o estoque
        // código para enviar notificação
        // ...
    }
}

// Bom
public class ProcessadorDePagamento
{
    public void ProcessarPagamento(Pedido pedido)
    {
        // código para processar o pagamento
    }
}

public class Estoque
{
    public void AtualizarEstoque(Pedido pedido)
    {
        // código para atualizar o estoque
    }
}

public class Notificador
{
    public void EnviarNotificacao(Pedido pedido)
    {
        // código para enviar notificação
    }
}

#7 Testes unitários:

Escreva testes unitários para validar o comportamento esperado do código. Isso garante que o código continue funcionando conforme as alterações são feitas. Por exemplo:

// Ruim
public void CalcularDesconto(decimal valorTotal)
{
    // código para calcular o desconto...
    // sem testes unitários
}

// Bom
public decimal CalcularDesconto(decimal valorTotal)
{
    // código para calcular o desconto...
    // com testes unitários
    // retorna o valor do desconto
}

#8 Evite efeitos colaterais:

Evite que uma função ou método tenha efeitos colaterais, ou seja, que altere o estado de variáveis ou objetos externos de maneira inesperada. Isso torna o código mais previsível. Por exemplo:

// Ruim
public void ImprimirRelatorio()
{
    // código para gerar o relatório...
    // e enviar por email
}

// Bom
public void GerarRelatorio()
{
    // código para gerar o relatório...
}

public void EnviarRelatorioPorEmail()
{
    // código para enviar o relatório por email...
}

#9 Código autodocumentado:

Escreva código que seja autoexplicativo e não dependa excessivamente de comentários. Use nomes significativos e estrutura clara para que o código se explique por si só. Por exemplo:

// Ruim
// Verifica se o usuário está logado
if (usuario != null)

// Bom
if (usuarioLogado != null)

#10 Refatoração contínua:

Procure sempre refatorar o código para melhorar sua qualidade. Identifique oportunidades de simplificação, eliminação de duplicação e melhoria da estrutura. Mantenha seu código sempre limpo e organizado. Por exemplo:

// Ruim
public void RealizarCalculo(float valor)
{
    // código extenso e confuso...
}

// Bom
public void Calcular(float valor)
{
    // código simplificado e mais claro...
}

Esses são apenas alguns dos princípios do Clean Code. Lembre-se de que a prática constante e a busca pela excelência são essenciais para se tornar um desenvolvedor de código limpo. Adote esses princípios em seu trabalho diário e colha os benefícios de um código mais legível, sustentável e de alta qualidade

Happy coding!

Livros sobre o assunto: