Evitando o Abuso do Else: Estratégias e Boas Práticas em Programação em C#

Desenvolver software claro e legível é fundamental para a manutenção e compreensão eficaz do código. Recentemente, uma discussão significativa surgiu na comunidade tech do Twitter sobre a recusa de Pull Requests (PRs) quando o else é usado. A justificativa é que o else prejudica a legibilidade e que há várias técnicas para evitar seu uso. Sendo assim, quais seriam essas formas para evitar o uso indiscriminado do else? Abaixo, apresento uma lista de estratégias para contornar o uso do else, destacando os pontos fortes e fracos de cada alternativa.

1. Early Return:
   • Pontos Fortes:
     • Reduz a profundidade dos blocos, facilitando a leitura.
     • Evita a necessidade de aninhar várias condições else.
   • Pontos Fracos:
     • Pode resultar em múltiplos pontos de retorno no código.
     • Alguns desenvolvedores consideram isso uma má prática, pois atrapalha o fluxo de debug da aplicação.

public bool ValidarDados(List<string> dados)
{
    if (dados == null || dados.Count == 0)
        return false;

    // Restante da lógica de validação
    return true;
}

1. Mapping com Dictionary em C#:
   • Pontos Fortes:
     • Simplifica a lógica, associando valores a comportamentos.
     • Reduz a necessidade de blocos else ao utilizar mapeamentos.
   • Pontos Fracos:
     • Pode aumentar a complexidade se o mapeamento for extenso.

Dictionary<string, Func<int, int, int>> operacoes = new Dictionary<string, Func<int, int, int>>
{
    { "soma", (x, y) => x + y },
    { "subtracao", (x, y) => x - y }
};

int resultado = operacoes["soma"](5, 3);

1. Break the Chain em .NET:
   • Pontos Fortes:
     • Divide operações complexas em etapas, facilitando a compreensão.
     • Reduz a necessidade de blocos else ao retornar antecipadamente.
   • Pontos Fracos:
     • Pode levar a muitas funções pequenas, tornando o código fragmentado.

public Resultado ProcessarDados(List<string> dados)
{
    if (!ValidarDados(dados))
        return null;

    // Processamento adicional
    return resultadoFinal;
}

1. Move Nested Blocks em C#:
   • Pontos Fortes:
     • Melhora a legibilidade ao mover condições aninhadas para funções separadas.
     • Facilita testes unitários de cada condição isoladamente.
   • Pontos Fracos:
     • Introduz mais funções no escopo.

private bool VerificarCondicao1()
{
    // Lógica da condição 1
}

private bool VerificarCondicao2()
{
    // Lógica da condição 2
}

if (VerificarCondicao1())
{
    // Lógica quando a condição 1 é verdadeira
}
else if (VerificarCondicao2())
{
    // Lógica quando a condição 2 é verdadeira
}

1. Uso de Strategy Pattern em C#:
   • Pontos Fortes:
     • Encapsula algoritmos em classes, eliminando a necessidade de else.
     • Facilita a extensão do código com novas estratégias.
   • Pontos Fracos:
     • Pode ser excessivo para problemas simples, na maioria dos casos é como usar uma bazuca para matar uma mosca

interface IEstrategia
{
    void Executar();
}

class EstrategiaA : IEstrategia
{
    public void Executar()
    {
        // Lógica da Estratégia A
    }
}

class EstrategiaB : IEstrategia
{
    public void Executar()
    {
        // Lógica da Estratégia B
    }
}

IEstrategia estrategia = new EstrategiaA(); // Estratégia inicial
estrategia.Executar(); // Executa a Estratégia A

1. Uso de Ternário para Melhorar Legibilidade em C#:
   • Pontos Fortes:
     • Em expressões curtas, proporciona uma alternativa legível.
     • Reduz a necessidade de blocos else em situações simples.
   • Pontos Fracos:
     • Pode se tornar confuso em expressões longas.

string status = (pontuacao >= 70) ? "Aprovado" : "Reprovado";

Conclusão:

Evitar o abuso do else é crucial para manter o código claro e legível em C#. Cada estratégia tem seus pontos fortes e fracos, e a escolha depende da complexidade do problema. Utilizando essas abordagens com sabedoria, os desenvolvedores podem criar um código mais robusto, legível e fácil de manter em projetos .NET.

Comments

[Rodrigo Britez Junior]

Muito top teu artigo

A maneira como você detalhou cada estratégia, desde o Early Return até o uso de Ternários, mostra um alto entendimento não apenas do C#, mas também dos princípios de design de software. Especialmente, gostei de como você equilibrou os pontos fortes e fracos de cada técnica, destacando que não existe uma 'bala de prata' na programação.

Seu exemplo de Early Return é um ótimo lembrete de como a simplicidade muitas vezes leva à maior clareza em código. E o uso do Strategy Pattern, apesar de suas limitações, é uma excelente demonstração de como o código pode ser estruturado de forma mais flexível e extensível.

Parabéns pela ótima contribuição e estou ansioso para ler mais dos seus insights no futuro!