Progamando, Tutorial

C# – Para Iniciantes – Parte 3 – Expressão Lambda

Olá Pessoal, Como utilizar uma Expressão Lambda?

De início elas podem assustar um pouco quem não as conhecem, mas basta entender o conceito para transformá-las em grandes aliadas no desenvolvimento de código bonito 😉

As expressões lambda foram introduzidas no .Net para dar suporte as consultas LINQ.

“LINQ – Language Integrated Query, foi introduzido no framework 3.5 para realizar consultas diretas a base de dados ou documentos XML, coleções de objetos e qualquer outra estrutura de dados. Sua sintaxe é parecida com a linguagem SQL”

As expressões lambda se comportam como um tipo de delegate (falaremos dele em breve). Entendemos que a expressão lambda é uma espécie de função, porém sem nome, elas realizam cálculos, filtros, e retornam um valor (ou uma coleção de valores).

Para criar uma expressão lambda é necessário fazer uso do operador lambda “=>” que podemos entender como “Vai para”.

Uma expressão lambda sempre consiste de duas partes (esquerda e direita) separadas pelo  “=>”. A parte à esquerda do “=>” contém uma lista de argumentos (de tipo não necessariamente definido, pois os tipos podem ser automáticamente indicados pelo compilador). O lado direito contém as instruções.

Esta é uma expressão lambda (linha 2):

1 int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
2 int oddNumbers = numbers.Count(n => n % 2 == 1);

O que está sendo feito?
Note que foi criado um Array de inteiros e atribuído a ele alguns elementos numéricos.
A expressão lambda está retornando os elementos do Array que são impares.

Como? Vamos ler da seguinte forma:
Está sendo retornado um array com apenas os números que satisfazerem a expressão   “n % 2 == 1”, nesse caso foram 5 dos 10 elementos numéricos.

Para quem não sabe x % y significa x módulo y, ou seja, o resto da divisão de x por y, qualquer número impar dividido por 2 resta 1, é assim que validamos números impares.

No final o método count totalizou os impares do array que foi retornado da expressão lamba.

Achou difícil? Vamos tentar esta:

1 // O var é uma forma de declarar uma variável que irá assumir o tipo do dado que lhe for atribuido.
2 var SelecoesMundiais = new ArrayList(new string[] {"USA", "Africa", "Mexico", "Brasil" });
3
4 // Primeira forma de fazer um filtro usando WHERE
5 var MelhorSelecao =
6         from string p in SelecoesMundiais
7         where p == "Brasil"
8         select p;
9
10 // Segunda forma de fazer um filtro usando WHERE
11 var MelhorSelecao2 = SelecoesMundiais.Cast<string>().Where(p => p == "Brasil");
12
13 // Aqui estamos fazendo a mesma coisa sem utilizar expressão lambda
14 List<string> MelhorSelecao3 = new List<string>();
15
16 foreach (var Selecao in SelecoesMundiais)
17 {
18     if (Selecao == "Brasil")
19     {
20         MelhorSelecao3.Add(Selecao.ToString());
21     }
22 }

Precisamos assumir que é mais fácil (e prático) usar expressões lambda 🙂
O último exemplo usando ForEach atende também, mas a quantidade de variáveis e de linhas de código é maior.

Segue mais um exemplo, a ideia desse código é receber uma lista com nomes duplicados, filtrar de forma que não se repitam e converter o nome para UPPER CASE.
Repare que esta sendo chamada uma função externa dentro de uma expressão lambda:

1 List<string> ListaNomesDistintos = new List<string>();
2
3 List<string> ListaNomes = new List<string>();
4
5 // Adicionando nomes à lista
6 ListaNomes.Add("Eduardo");
7 ListaNomes.Add("Enzo");
8 ListaNomes.Add("Edna");
9 ListaNomes.Add("Juliana");
10 ListaNomes.Add("Eduardo");
11 ListaNomes.Add("Enzo");
12
13 // Atribuindo para nova lista o retorno dos dados tratados pelo Distinct.
14 // O Distinct no LINQ assim como no SQL é responsável por eliminar duplicações de informação.
15 ListaNomesDistintos = ListaNomes.Distinct().ToList();
16
17 // Utilizando o ForEach genérico com uma expressão lambda.
18 // Basicamente está pegando cada elemento e jogando dentro da função TransformaUpperCase.
19 ListaNomesDistintos.ForEach(n => TransformaUpperCase(n));
20
21 // Aqui você pode verificar que os nomes não estão duplicados e foram transformados em UPPERCASE.
22 public void TransformaUpperCase(string nome)
23 {
24     MessageBox.Show(nome.ToUpper());
25 }

Com esse exemplo podemos entender o quanto podemos explorar a capacidade das expressões lambda.

Esse post é apenas uma pequena amostra dos recursos, recomendo a vocês que deixem as expressões lambda fazerem parte de seus códigos, as vantagens são diversas.
Pretendo mostrar a utilização de expressão lambda em cenários mais complexos em um próximo post.

Utilizem os comentários para tirar dúvidas 🙂

Referências: