Expresiones Lambda en LINQ: Guía Completa para C#

Las expresiones lambda han revolucionado la forma en que los desarrolladores trabajan con colecciones de datos en C#. Junto con LINQ (Language Integrated Query), permiten escribir código más conciso, limpio y eficiente. En esta guía completa, exploraremos cómo funcionan las expresiones lambda, su integración con LINQ y una variedad de ejemplos prácticos.

---

1. Introducción a las Expresiones Lambda

Una expresión lambda es una función anónima que permite definir métodos en una sola línea de código. Se utilizan ampliamente en LINQ para transformar y filtrar datos de manera eficiente.

La sintaxis básica es:

(parametros) => expresion_o_bloque_de_codigo;

Ejemplo básico de una expresión lambda que suma dos números:

Func<int, int, int> suma = (a, b) => a + b;
Console.WriteLine(suma(3, 5)); // Salida: 8

El operador => separa los parámetros de la función de la expresión o bloque de código que la define.

---

2. Ventajas de Usar Expresiones Lambda

1. Código más conciso: Reduce la cantidad de código necesario para definir funciones.
2. Mayor legibilidad: Se integra mejor en consultas LINQ, haciendo que sean más intuitivas.
3. Optimización del rendimiento: LINQ y el compilador optimizan la ejecución de estas expresiones.
4. Uso con delegados genéricos: Se combinan fácilmente con Func<T> y Action<T>.

---

3. Uso de Expresiones Lambda en LINQ

3.1. Filtrado de Datos con Where

List<int> numeros = new List<int> { 1, 2, 3, 4, 5, 6 };
var numerosPares = numeros.Where(n => n 

Console.WriteLine(string.Join(", ", numerosPares)); // Salida: 2, 4, 6

3.2. Transformación de Datos con Select

List<string> nombres = new List<string> { "Ana", "Bruno", "Carlos" };
var nombresMayusculas = nombres.Select(n => n.ToUpper()).ToList();

Console.WriteLine(string.Join(", ", nombresMayusculas)); // ANA, BRUNO, CARLOS

3.3. Ordenamiento de Datos con OrderBy y OrderByDescending

List<int> valores = new List<int> { 5, 1, 4, 3, 2 };
var valoresOrdenados = valores.OrderBy(v => v).ToList();
var valoresDescendentes = valores.OrderByDescending(v => v).ToList();

3.4. Búsqueda de Elementos con First y FirstOrDefault

List<int> lista = new List<int> { 3, 7, 10, 15 };
var primerMayorA5 = lista.First(n => n > 5);
Console.WriteLine(primerMayorA5); // 7

3.5. Agrupación de Datos con GroupBy

var personas = new List<Persona>
{
    new Persona { Nombre = "Ana", Ciudad = "Madrid" },
    new Persona { Nombre = "Bruno", Ciudad = "Madrid" },
    new Persona { Nombre = "Carlos", Ciudad = "Barcelona" }
};

var grupos = personas.GroupBy(p => p.Ciudad);

foreach (var grupo in grupos)
{
    Console.WriteLine($"Ciudad: {grupo.Key}");
    foreach (var persona in grupo)
    {
        Console.WriteLine($"  - {persona.Nombre}");
    }
}

3.6. Cálculos con Aggregate, Sum y Average

List<int> edades = new List<int> { 20, 25, 30, 35, 40 };
double promedio = edades.Average();
int suma = edades.Sum();

Console.WriteLine($"Edad Promedio: {promedio}"); // 30
Console.WriteLine($"Suma Total: {suma}"); // 150

---

4. Expresiones Lambda Complejas

Las expresiones lambda no están limitadas a una sola línea. También pueden contener múltiples líneas dentro de llaves {}:

Func<int, int, int> operacion = (a, b) =>
{
    int resultado = a * b;
    return resultado + 10;
};
Console.WriteLine(operacion(2, 3)); // 16

---

5. Expresiones Lambda con Func<T> y Action<T>

Las expresiones lambda son compatibles con Func<T> y Action<T>, que permiten definir delegados de forma sencilla.

Func<int, int, int> multiplicar = (a, b) => a * b;
Console.WriteLine(multiplicar(4, 5)); // 20

Action<string> imprimir = mensaje => Console.WriteLine(mensaje);
imprimir("Hola, mundo"); // Hola, mundo

---

6. Ejemplo Completo de LINQ con Expresiones Lambda

using System;
using System.Collections.Generic;
using System.Linq;

class Persona
{
    public string Nombre { get; set; }
    public int Edad { get; set; }
    public string Ciudad { get; set; }
}

class Program
{
    static void Main()
    {
        List<Persona> personas = new List<Persona>
        {
            new Persona { Nombre = "Ana", Edad = 20, Ciudad = "Barcelona" },
            new Persona { Nombre = "David", Edad = 25, Ciudad = "Madrid" },
            new Persona { Nombre = "Carolina", Edad = 30, Ciudad = "Barcelona" },
            new Persona { Nombre = "Bruno", Edad = 35, Ciudad = "Sevilla" },
            new Persona { Nombre = "Elena", Edad = 40, Ciudad = "Madrid" }
        };

        var mayoresDe30 = personas.Where(p => p.Edad > 30).ToList();
        var personasOrdenadas = personas.OrderBy(p => p.Nombre).ToList();
        var ciudadesUnicas = personas.Select(p => p.Ciudad).Distinct().ToList();
        var edadPromedio = personas.Average(p => p.Edad);
        var personaMasJoven = personas.OrderBy(p => p.Edad).First();
    }
}

---

Conclusión

Las expresiones lambda son una herramienta poderosa en C# que permiten escribir consultas y manipulaciones de datos de manera clara y eficiente. Su integración con LINQ proporciona una forma natural y concisa de filtrar, ordenar y transformar datos.

Para seguir explorando LINQ y programación en C#, suscríbete a mi blog donde comparto tutoriales avanzados y consejos prácticos.