Expressões Lambda e LINQ em C#

Claro! Vamos explorar os conceitos de expressões lambda e consultas LINQ na linguagem C#.

Expressões Lambda em C#

As expressões lambda são funções anônimas que permitem escrever código de forma mais concisa e expressiva. Elas são frequentemente usadas em métodos que aceitam delegates como parâmetros ou para criar delegates de forma mais rápida e simples.

Em C#, uma expressão lambda possui a seguinte sintaxe básica:

scssCopy code
(argumentos) => expressão

Por exemplo, considere o seguinte código que define uma expressão lambda que adiciona dois números:

csharpCopy code
Func<int, int, int> soma = (x, y) => x + y;
Console.WriteLine(soma(3, 4)); // Saída: 7

Neste exemplo, (x, y) são os argumentos da expressão lambda, x + y é a expressão que define o comportamento da função e Func é o tipo delegate que representa uma função que recebe dois inteiros e retorna outro inteiro.

As expressões lambda são especialmente úteis em métodos de extensão LINQ, onde podem ser usadas para expressar predicados e transformações de forma concisa.

Consultas LINQ em C#

As consultas LINQ (Language Integrated Query) são uma característica poderosa da linguagem C# que permite realizar consultas em coleções de dados de forma semelhante à linguagem SQL.

Para usar consultas LINQ, primeiro você precisa importar o namespace System.Linq. Em seguida, você pode escrever consultas usando a sintaxe de consulta ou a sintaxe de método.

Aqui está um exemplo usando a sintaxe de consulta para encontrar todos os números pares em uma lista:

csharpCopy code
using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numeros = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        var numerosPares =
            from num in numeros
            where num % 2 == 0
            select num;

        foreach (var num in numerosPares)
        {
            Console.WriteLine(num);
        }
    }
}

Este código irá produzir a seguinte saída:

Copy code
2
4
6
8
10

Agora, vamos reescrever o mesmo código usando a sintaxe de método:

csharpCopy code
using System;
using System.Linq;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        List<int> numeros = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        var numerosPares = numeros.Where(num => num % 2 == 0);

        foreach (var num in numerosPares)
        {
            Console.WriteLine(num);
        }
    }
}

Ambos os exemplos produzirão a mesma saída. A diferença é apenas na sintaxe usada para escrever a consulta LINQ.

Em resumo, as expressões lambda e as consultas LINQ são recursos poderosos da linguagem C# que permitem escrever código mais conciso e expressivo, facilitando a manipulação e consulta de coleções de dados.

Claro! Vamos explorar mais detalhadamente as expressões lambda e as consultas LINQ em C#.

Expressões Lambda em C#

As expressões lambda são uma característica introduzida no C# 3.0 que permite criar funções anônimas de forma concisa. Elas são frequentemente utilizadas em cenários onde é necessário passar uma função como argumento para métodos que aceitam delegates, como métodos de extensão LINQ, manipulação de eventos e programação assíncrona.

A sintaxe básica de uma expressão lambda em C# é:

scssCopy code
(argumentos) => expressão

onde:

• argumentos são os parâmetros da função.
• expressão é o corpo da função.

Por exemplo, considere a seguinte expressão lambda que calcula o quadrado de um número:

csharpCopy code
Func<int, int> quadrado = x => x * x;
Console.WriteLine(quadrado(5)); // Saída: 25

Neste exemplo, x é o argumento da expressão lambda e x * x é a expressão que define o comportamento da função.

As expressões lambda também podem capturar variáveis locais do contexto onde são definidas. Isso é conhecido como “captura de variáveis locais” ou “encerramento”. Por exemplo:

csharpCopy code
int multiplicador = 2;
Func<int, int> dobrar = x => x * multiplicador;
Console.WriteLine(dobrar(5)); // Saída: 10

Neste caso, a expressão lambda captura a variável multiplicador do contexto onde foi definida.

Consultas LINQ em C#

As consultas LINQ (Language Integrated Query) são uma forma poderosa de realizar consultas em coleções de dados, bancos de dados e outros tipos de fontes de dados. Elas oferecem uma sintaxe expressiva e uniforme para consultas, permitindo escrever consultas de forma semelhante à linguagem SQL, mas integradas diretamente na linguagem C#.

Existem duas sintaxes principais para escrever consultas LINQ em C#: a sintaxe de consulta e a sintaxe de método.

Sintaxe de Consulta

Na sintaxe de consulta, as consultas são escritas de forma semelhante à linguagem SQL, usando palavras-chave como from, where, select, orderby, entre outras. Por exemplo:

csharpCopy code
var numerosPares =
    from num in numeros
    where num % 2 == 0
    select num;

Neste exemplo, numeros é uma coleção de números e num é uma variável de intervalo que representa cada número na coleção. A consulta filtra os números pares usando a cláusula where e seleciona os números pares usando a cláusula select.

Sintaxe de Método

Na sintaxe de método, as consultas são escritas usando métodos de extensão LINQ diretamente nas coleções de dados. Por exemplo:

csharpCopy code
var numerosPares = numeros.Where(num => num % 2 == 0);

Neste exemplo, Where é um método de extensão LINQ que filtra os números pares da coleção numeros, usando uma expressão lambda como predicado.

Ambas as sintaxes produzem o mesmo resultado e são igualmente poderosas. A escolha entre elas geralmente depende da preferência pessoal e do estilo de codificação da equipe.

Conclusão

As expressões lambda e as consultas LINQ são recursos poderosos da linguagem C# que permitem escrever código mais conciso, legível e expressivo. Elas facilitam a manipulação e consulta de coleções de dados, tornando o desenvolvimento de aplicativos mais eficiente e produtivo. Dominar esses conceitos é essencial para qualquer desenvolvedor C# que deseja escrever código de alta qualidade e manutenível.