C# 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):

int[] numbers = { 5, 4, 1, 3, 9, 8, 6, 7, 2, 0 };
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:

// O var é uma forma de declarar uma variável que irá assumir o tipo do dado que lhe for atribuido.
var SelecoesMundiais = new ArrayList(new string[] {"USA", "Africa", "Mexico", "Brasil" });

// Primeira forma de fazer um filtro usando WHERE
var MelhorSelecao =
from string p in SelecoesMundiais
where p == "Brasil"
select p;

// Segunda forma de fazer um filtro usando WHERE
var MelhorSelecao2 = SelecoesMundiais.Cast<string>().Where(p => p == "Brasil");

// Aqui estamos fazendo a mesma coisa sem utilizar expressão lambda
List<string> MelhorSelecao3 = new List<string>();

foreach (var Selecao in SelecoesMundiais)
{
  if (Selecao == "Brasil")
  {
    MelhorSelecao3.Add(Selecao.ToString());
  }
}

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:

List<string> ListaNomesDistintos = new List<string>();
List<string> ListaNomes = new List<string>();

// Adicionando nomes à lista
ListaNomes.Add("Fabrizio");
ListaNomes.Add("Enzo");
ListaNomes.Add("Edna");
ListaNomes.Add("Juliana");
ListaNomes.Add("Eduardo");
ListaNomes.Add("Enzo");

// Atribuindo para nova lista o retorno dos dados tratados pelo Distinct.
// O Distinct no LINQ assim como no SQL é responsável por eliminar duplicações de informação.
ListaNomesDistintos = ListaNomes.Distinct().ToList();

// Utilizando o ForEach genérico com uma expressão lambda.
// Basicamente está pegando cada elemento e jogando dentro da função TransformaUpperCase.
ListaNomesDistintos.ForEach(n => TransformaUpperCase(n));

// Aqui você pode verificar que os nomes não estão duplicados e foram transformados em UPPERCASE.
public void TransformaUpperCase(string nome)
{
  MessageBox.Show(nome.ToUpper());
}

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