C# - Usando expressões lambdas para os delegates Predicate, Func e Action com listas genéricas

C# - Usando expressões lambdas para os argumentos Predicate, Func e Action em listas genéricas

Para você poder acompanhar e entender este artigo você tem que saber o que é um delegate. Se você tem dúvidas leia o meu artigo : C# - Delegates e Eventos : Conceitos básicos e depois prossiga na leitura.

Eu não vou entrar em detalhes sobre o que é um delegate (para detalhes leia o artigo) vou apenas apresentar a sua definição (uma delas):

Sugiro também que leia os artigos sobre os delegates Predicate, Func e Action já publicados no site. (veja as referências)

As listas genéricas são uma ótima maneira de armazenar, recuperar e geralmente trabalham com objetos. A maioria dos métodos em uma classe de lista genérica toma como argumentos tanto um Predicate, uma Func ou uma Action e isso pode confundir quem esta iniciando na linguagem.

Neste artigo eu mostro como usar esses recursos de forma a tornar o seu código mais elegante usando expressões lambda para todos esses três tipos de argumentos.

Assim em uma lista genérica esses argumentos permitem ao desenvolvedor executar um método para cada um dos itens na lista genérica.

A seguir no meu PROJECT clique em Add Class e informe o nome Estoque definindo o código conforme abaixo:

Nossa classe Estoque possui 4 propriedades e um construtor que iremos usar para criar uma lista genérica de itens em estoque.

A seguir na classe Program vamos definir a criação da lista através do método preencheLista() e a sua exibição pelo método exibeLista() conforme o código a seguir:

Executando o projeto neste momento teremos a lista de itens em estoque conforme a figura a seguir:

Agora que já temos tudo pronto vamos mostrar como usar expressões lambdas com argumentos Predicate, Func e Action da lista genérica.

Métodos de uma lista genérica com argumento Predicate

O método para localizar um item, ou método Find, da lista genérica é um exemplo de método que toma um argumento Predicate.

Antes de criar a classe Predicate vamos dar uma olhada como a localização de um item é feita de forma tradicional:

 public Estoque FindEstoqueForeach(int itemId)
 {
     foreach (Estoque item in _listaInventario)
     {
                if (item.Id == itemId)
                    return item;
      }
      return null;
}

O código usa um laço foreach para percorrer a lista de itens e localizar o item pelo seu id.

O código funciona mas existe uma maneira melhor de realizar esta tarefa. A classe da lista genérica já possui um método Find e o argumento para este método é a classe Predicate.

Lembre que o delegate Predicate toma parâmetros, executa o código usando os parâmetros e sempre retorna um boleano.

Na linguagem C# um delegate cria um método anônimo e este pode ser atribuído a uma variável Predicate que pode então ser passada para o método Find. Veja como fica o método usando o argumento Predicate:

public Estoque FindEstoquePredicate(int itemId)
{
   Predicate<Estoque> pred = delegate(Estoque item)
   {
       return item.Id == itemId;
   };
  return _listaInventario.Find(pred);
}

Isto pode ser útil se você desejar armazenar o delegate para reutilizar. Agora vamos usar as expressões lambdas para simplificar o código. Veja como ficou mais enxuto:

public Estoque FindEstoque(int itemId)
{
    return _listaInventario.Find(item => item.Id == itemId);
}

Vamos entender o código:

1- A parte esquerda representa os parâmetros para a função a serem avaliados, neste caso, o tipo Estoque;

2- O lado direito é uma expressão booleana que irá avaliar como verdade quando o método Find encontra o item com 'itemId';

3- Se o item não for encontrado, o método FindEstoque retornará null;

Além do método Find temos os seguintes métodos de uma lista genérica que possuem um argumento Predicate:

FindAll – Retorna uma lista de objeto que atendem uma condição;
RemoveAll – Remove o objeto que atende uma condição;
Exists – Verifica se o objeto que atende a uma condição existe;
FindLast – Retorna o último objeto que atende a uma condição;

Existem muitos métodos de Lista genérica que usam um tipo Func como um argumento. Lembre-se da definição do delegate Func: "um delegado que leva parâmetro(s), executa o código usando o parâmetro(s) e retorna o tipo que você definir".

O argumento Func é mais flexível do que Predicate pois ele pode retornar qualquer tipo, não apenas um boleano. Isso depende do método da lista quanto à assinatura do Func. Alguns tomam um argumento, outros mais.

Um dos métodos mais úteis é o método de extensão Enumerable chamado Where.

Pense na cláusula SQL WHERE quando se utiliza este método. Ele permite que você obtenha um subconjunto da lista. A seguir temos um exemplo:

Note que para retornar uma lista de itens do estoque você precisa chamar o método ToList() pois Where retorna um IEnumerable e a consulta não é executada até que o resultado seja enumerado.

Uma simplificação melhor simplesmente passa a expressão lambda diretamente para o método Where conforme vemos abaixo:

Existe um método de uma lista genérica que toma um argumento Action. É o método ForEach que executa o código especificado para cada um dos itens na lista. (Lembre-se que o delegate Action não retorna nada.)

A seguir temos um exemplo onde estamos alterando o valor do preço para todos os itens da lista:

Da mesma forma podemos realizar qualquer operação sobre cada item da lista usando ForEach. A seguir temos um exemplo onde estamos combinando os argumentos Action, Func e Predicate para remover os itens da lista de estoque cujo código atende uma condição:

Porque os judeus pedem sinal, e os gregos buscam sabedoria;
Mas nós pregamos a Cristo crucificado, que é escândalo para os judeus, e loucura para os gregos.
Mas para os que são chamados, tanto judeus como gregos, lhes pregamos a Cristo, poder de Deus, e sabedoria de Deus.
1 Coríntios 1:22-24