Melhore seu código — parte 3 — expressões lambda

Melhore seu código — parte 3 — expressões lambda

Continuando a nossa série de melhorias de código:

Parte 1 (link) — Melhore seu código C# — parte 2 — tem “if” demais no código !

Parte 2 (link) — Melhore seu código c# — parte 1 — a regra do escoteiro!

agora veremos como aplicar melhoria de código em expressões lambda !

Lambdas

Quem nunca viu um código que filtra uma lista de objetos com base em múltiplas condições usando uma expressão lambda complexa? Esta ainda está simples, mas temos situações até piores na vida real !

Exemplo:

var filteredItems = items.Where(item =>
    item.IsActive && 
    item.Price > 100 && 
    (item.Category == "Electronics" || item.Category == "Books") && 
    item.Stock > 0
).ToList();

Essa expressão lambda, embora funcional, não é muito legível. Se mais condições forem adicionadas, ela pode se tornar difícil de manter e testar.

Uma maneira de melhorar essa expressão é extrair as condições em métodos separados. Esses métodos não só melhoram a legibilidade, mas também permitem que você escreva testes unitários para cada uma das condições individualmente

Exemplo depois:

public bool IsEligible(Item item)
{
    return IsActive(item) && 
           IsPriceValid(item) && 
           IsCategoryValid(item) && 
           IsInStock(item);
}

private bool IsActive(Item item) => item.IsActive;

private bool IsPriceValid(Item item) => item.Price > 100;

private bool IsCategoryValid(Item item) =>
    item.Category == "Electronics" || item.Category == "Books";

private bool IsInStock(Item item) => item.Stock > 0;

var filteredItems = items.Where(IsEligible).ToList();

Ficou muito mais fácil de validar e testar cada parte da instrução !

Vantagens da Abordagem “Depois”

1. Legibilidade: Agora o código é mais fácil de entender, pois cada método tem um propósito claro.
2. Reutilização: As condições podem ser reutilizadas em outras partes do código sem precisar duplicar a lógica.
3. Testabilidade: Cada método pode ser testado individualmente, o que facilita a detecção e correção de bugs.
4. Manutenção: Alterar a lógica de qualquer condição agora é mais simples, já que está isolada em um método específico.

Exemplos de Testes Unitários

Com os métodos extraídos, você pode escrever testes unitários que validam cada condição separadamente, o que facilita identificar mudanças e problemas em partes específicas, difíceis de identificar no formato anterior:

[Test]
public void TestIsPriceValid()
{
    var item = new Item { Price = 150 };
    Assert.IsTrue(IsPriceValid(item));

    item.Price = 50;
    Assert.IsFalse(IsPriceValid(item));
}

[Test]
public void TestIsCategoryValid()
{
    var item = new Item { Category = "Electronics" };
    Assert.IsTrue(IsCategoryValid(item));

    item.Category = "Clothing";
    Assert.IsFalse(IsCategoryValid(item));
}

Com estes testes, temos uma ajuda para garantir que cada parte da sua lógica funcione corretamente e facilite a manutenção e expansão do código no futuro.

No próximo Post da série trarei outras dicas para melhorar o código !

Gostou do artigo? clique no ícone👏e me siga para ver as próximas publicações !! Quer ver mais conteúdos, acesse minhas redes através do Linktree: https://linktree.com/nizzola