Evitando o Abuso do Else: Estratégias e Boas Práticas em Programação em C#
Tags: dotnet, learning, codenewbie, braziliandevs
Published: 2024-02-18 23:12:14

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.

```csharp
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.

```csharp
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.

```csharp
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.

```csharp
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

```csharp
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.

```csharp
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.