O que é Clean Code? Confira as melhores dicas!

    // Simula uma operação assíncrona, como uma consulta ao banco de dados

    return await _produtoRepository.BuscarPorCategoriaAsync(categoriaId);

Evite configurações desnecessárias

Procure não deixar configurações que ainda não tiverem seus objetivos determinados por alguém. Lembre-se sempre de deixar o código o mais limpo possível e descomplicado. 

Evite:

public class Servico

{

    private string _parametro = "";

    public Servico()

    {

        _parametro = "ValorPadrao"; // Definição sem necessidade

    }

}

Recomendado:

public class Servico

{

    private readonly string _parametro;

    public Servico(string parametro)

    {

        _parametro = parametro ?? throw new ArgumentNullException(nameof(parametro));

    }

}

Utilize injeção de dependência

Para deixar o código mais limpo e desamarrado, use injeção de dependência na programação. 

Evite:

public class UsuarioService

{

    private UsuarioRepository _repository;

    public UsuarioService()

    {

        _repository = new UsuarioRepository(); // Alto acoplamento

    }

}

Recomendado:

public class UsuarioService

{

    private readonly IUsuarioRepository _repository;

    public UsuarioService(IUsuarioRepository repository)

    {

        _repository = repository;

    }

}

Lei de Demeter

A Lei de Demeter (LoD), também conhecida como Princípio do Menor Conhecimento, estabelece diretrizes para promover um design de software mais modular e desacoplado. Seus principais pontos são:

Vejamos um exemplo:

Classes básicas:

public class Pedido

{

    public Pagamento Pagamento { get; set; }

}

public class Pagamento

{

    public decimal Valor { get; set; }

    public void Processar() 

    { 

        // Lógica para processar o pagamento

    }

}

Mau exemplo (violando a Lei de Demeter):

public class ProcessadorPedido

{

    public void FinalizarPedido()

    {

        var pedido = new Pedido();

        pedido.Pagamento.Processar(); // <-- Acesso direto a um objeto distante

    }

}

Bom exemplo (respeitando a Lei de Demeter):

public class Pedido

{

    public Pagamento Pagamento { get; set; }

    public void Finalizar()

    {

        Pagamento?.Processar(); // Encapsula a lógica dentro da classe Pedido

    }

}

public class ProcessadorPedido

{

    public void FinalizarPedido()

    {

        var pedido = new Pedido();

        pedido.Finalizar(); // Interage apenas com o objeto imediato (Pedido)

    }

Regras sobre entendimento de código

Entender os códigos é essencial para manter a programação bem escrita e com fácil manutenção. Ser consistente, utilizar variáveis concisas, evitar dependências lógicas, entre outras regras vão te ajudar nisso. Veja abaixo.

Seja consistente

A consistência na aplicação do código é fundamental. Caso queira seguir um padrão, mantenha-o em todo o projeto. Isso facilita a leitura e a manutenção do código.

Evite:

int dias;  // Nome genérico

int quantidadeDiasNoAno = 365;

Recomendado:

int diasNoAno = 365;

int diasNoMes = 30;

Utilize variáveis concisas

Variáveis devem ser autoexplicativas, evitando a necessidade de comentários adicionais. Escolha nomes que descrevam claramente o propósito da variável. Por exemplo:

// Total do que?

decimal total = 0;

// Total do carrinho de compras

decimal shoppingCartTotal = 0;

Obsessão primitiva

Não foque apenas em tipos primitivos (Built-in). Utilize objetos de valor (Value Objects) para representar conceitos mais complexos e melhorar a clareza do código.

Evite:

public class Pedido

{

    public string EnderecoEntrega { get; set; }

}

Recomendado:

public class Endereco

{

    public string Rua { get; set; }

    public string Cidade { get; set; }

    public string Estado { get; set; }

}

public class Pedido

{

    public Endereco EnderecoEntrega { get; set; }

}

Evite dependências lógicas

Métodos não devem depender de condições específicas de sua classe para funcionar corretamente. Isso pode levar a comportamentos inesperados e dificultar a manutenção.

Evite:

public class Usuario

{

    public bool Logado;

    public void AcessarSistema()

    {

        if (Logado)

        {

            Console.WriteLine("Acesso permitido");

        }

    }

}

Recomendado:

public class Usuario

{

    public bool Logado { get; private set; }

    public void Login()

    {

        Logado = true;

    }

}

Evite condicionais negativas

Condicionais negativas podem dificultar a leitura do código. Prefira condições positivas para melhorar a clareza. 

Evite:

if(!IsSubscriber) { ... }

Utilize: 

if(IsSubscriber) { ... }

Regras de nomes

Escolha nomes descritivos e significativos para garantir a clareza e a manutenção do código. Nomes bem escolhidos reduzem a necessidade de explicações adicionais e facilitam a compreensão do que o código faz. 

Confira algumas dicas para esta que é uma das práticas mais importantes.

Escolha nomes descritivos

Nomes de classes, variáveis e métodos devem ser claros e expressivos. Se você precisa explicar o que um nome representa, significa que você pode melhorá-lo.

Evite:

var y = 100;

// Altura do que? Em qual unidade?

int height = 10;

// Muito mais expressivo

int heightInCentimeters = 10;

Faça distinções significantes

Nomes devem ser distintos o suficiente para que seu significado seja claro e não se confunda com outros nomes no código.

Evite:

var valor = 1500M;

// Tem um significado maior

var valorEmDolares = 1500M;

Utilize nomes com fácil busca e pronúncia

Evite nomes com pronúncia difícil ou criar convenções que não sejam intuitivas. Nomes claros e fáceis de buscar ajudam na manutenção do código.

Evite:

var xptoVar = "valor";

Recomendado:

var nomeCliente = "João";

Evite o excesso de strings

O uso repetido de strings pode levar a erros difíceis de detectar. Utilize constantes para não se deparar com problemas de comparação e não desperdiçar tempo buscando um bug.

Evite:

if (status == "ATIVO") { ... }

Recomendado:

public class Status

{

    public const string Ativo = "ATIVO";

}

if (status == Status.Ativo) { ... }

Não use prefixo ou caracteres especiais

Evite prefixos que indicam o tipo da variável, método ou classe. Além disso, nunca utilize espaços ou caracteres especiais em nomes.

Evite:

public class clsCustomer { ... }

Evite:

string strNome = "José";

Evite:

var situação - "Pendente";

Regras para funções ou métodos

Regras como expressividade, coerência e códigos não comentados, são importantes para garantir que suas funções sejam eficientes e fáceis de entender.

Pequenas e com objetivo único

Métodos devem ser pequenos e focados em uma única tarefa. Isso facilita a reutilização e a compreensão do código.

Evite:

public void ProcessarPedido()

{

    ValidarCliente();

    CalcularFrete();

    GerarFatura();

}

Recomendado:

public void ValidarCliente() { ... }

public void CalcularFrete() { ... }

public void GerarFatura() { ... }

Utilize nomes descritivos

Nomes de métodos devem ser claros e descritivos, refletindo exatamente o que o método faz, sem usar caracteres especiais.

Evite:

// O que esse método faz?

public void Calcular() { ... }

Utilize:

// Calcula o valor do frete

public void CalcularFrete() { ... }

Utilize poucos parâmetros

Tente não exigir muitas coisas de um mesmo objeto. Utilize objetos ou parâmetros opcionais para simplificar a assinatura do método como o Optional Parameters do C#.

Evite:

public void CriarPedido(string produto, int quantidade, double preco, string cliente)

Recomendado:

public void CriarPedido(Pedido pedido)

Tenha cuidado com efeitos colaterais

Se uma função alterar valores de outra classe sem ser a dela, isto vai gerar um efeito colateral.

Evite:

public void AplicarDesconto(Pedido pedido)

{

    pedido.Valor -= 10;

}

Recomendado:

public class Pedido

{

    public decimal Valor { get; private set; }

    public void AplicarDesconto(decimal desconto)

    {

        Valor -= desconto;

    }

}

Não tome decisões desnecessárias

Evite o uso de "flags" para tomar decisões dentro de métodos. Divida a lógica em métodos separados ou outras classes.

Evite:

public void Processar(bool isPagamentoCredito)

{

    if (isPagamentoCredito)

        ProcessarCartao();

    else

        ProcessarBoleto();

}

Recomendado:

public void ProcessarCartao() { ... }

public void ProcessarBoleto() { ... }

Regras de comentários

Comentários podem ser úteis, mas seu uso deve ser criterioso para evitar redundâncias e poluição no código. Não ser redundante, não fechar comentários, colocar intenção e esclarecimento, são parte das regras que guiam o uso adequado de comentários. Veja a seguir.

Um código bom é expressivo

Em teoria, quando é preciso comentar uma parte do código, é porque ele não está claro o suficiente. 

// Função que inicia o sistema

public void IniciarSistema() { ... }

Não seja redundante

Se um comentário não faz sentido para o contexto ou cenário, evite colocá-lo.

// Verifica se o usuário está logado

if (usuario.Logado) { ... }

Não feche os comentários

Fechar comentários com barras ou outros caracteres é desnecessário e polui o código.

// Este é um comentário // <- Fechamento desnecessário

public void ProcessarDados() { ... }

Evite códigos comentados

Códigos comentados podem ser confusos e dificultam a leitura, para deixar o código limpo e organizado, remova estes trechos. Caso você precise recuperar códigos antigos, utilize versionadores de código.

Intenção

Comentários podem ser úteis para explicar a intenção por trás de um método, classe ou variáveis.

// Retorna os usuários inativos para o processo de limpeza mensal

public IList ObterUsuariosInativos() </em></p>

{