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("Eduardo");
    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.

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:

• Expressões Lambda – Microsoft
• LINQ (Language-Integrated Query)