Expresiones Lambda en C#

En C#, las expresiones lambda permiten escribir métodos anónimos (sin nombre) de manera breve y legible. Se definen usando el operador => (operador lambda). Las expresiones lambda se utilizan especialmente en consultas LINQ, suscripción a eventos y en el estilo de programación funcional.

Sintaxis básica de Lambda

Una expresión lambda consta de una lista de parámetros y un cuerpo. En expresiones simples no se necesitan llaves; en cuerpos de varias líneas se pueden usar llaves y la palabra return.

// Un parámetro, expresión de una sola línea
Func<int, int> cuadrado = x => x * x;
Console.WriteLine(cuadrado(5)); // 25

// Lambda con varios parámetros
Func<int, int, int> sumar = (a, b) => a + b;
Console.WriteLine(sumar(3, 4)); // 7

// Lambda de varias líneas
Func<int, int, int> multiplicar = (a, b) =>
{
    Console.WriteLine($"Multiplicando: {a} * {b}");
    return a * b;
};
Console.WriteLine(multiplicar(2, 6)); // 12

Lambda con Action y Func

Las expresiones lambda suelen usarse con los tipos Action y Func:

• Action: Representa métodos que no devuelven valor.
• Func<T,..., TResult>: Representa métodos que devuelven un valor.

Action saludar = () => Console.WriteLine("¡Hola!");
saludar(); // ¡Hola!

Func<string, int> longitud = s => s.Length;
Console.WriteLine(longitud("Lambda")); // 6

Lambda y LINQ

Las expresiones lambda se usan sobre todo en las consultas LINQ. Permiten filtrar, ordenar y proyectar colecciones fácilmente.

var numeros = new List<int> { 1, 2, 3, 4, 5, 6 };

// Filtrar números pares
var pares = numeros.Where(x => x % 2 == 0);

Console.WriteLine(string.Join(", ", pares)); // 2, 4, 6

// Calcular los cuadrados
var cuadrados = numeros.Select(x => x * x);
Console.WriteLine(string.Join(", ", cuadrados)); // 1, 4, 9, 16, 25, 36

Uso de Lambda con Eventos

Las expresiones lambda son una forma práctica de manejar eventos. Permiten capturar un evento de forma concisa sin definir un método separado.

public class Button
{
    public event EventHandler? Click;

    public void SimulateClick()
    {
        Console.WriteLine("¡Botón presionado!");
        Click?.Invoke(this, EventArgs.Empty);
    }
}

class Program
{
    static void Main()
    {
        var btn = new Button();

        // Capturar evento con lambda
        btn.Click += (s, e) => Console.WriteLine("Evento: se hizo clic en el botón.");

        btn.SimulateClick();
    }
}

Cierre (Closure) y Captura de Variables

Las expresiones lambda pueden acceder a las variables en el ámbito donde se definen. A esto se le llama closure.

int contador = 0;

Action incrementar = () =>
{
    contador++;
    Console.WriteLine($"Contador: {contador}");
};

incrementar(); // Contador: 1
incrementar(); // Contador: 2

Aquí, la expresión lambda “captura” la variable externa contador y sigue operando sobre ella.

Ejemplo: Filtrado y Reporte

En una aplicación de tienda, se pueden usar expresiones lambda para filtrar productos según su precio y generar reportes.

public class Product
{
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
}

class Program
{
    static void Main()
    {
        var productos = new List<Product>
        {
            new Product { Name = "Portátil", Price = 25000m },
            new Product { Name = "Ratón", Price = 300m },
            new Product { Name = "Teclado", Price = 600m },
            new Product { Name = "Monitor", Price = 4500m }
        };

        // Encontrar productos con precio mayor a 1000
        var productosCaros = productos.Where(p => p.Price > 1000);

        foreach (var p in productosCaros)
        {
            Console.WriteLine($"{p.Name} - {p.Price} EUR");
        }

        // Calcular precio promedio
        var prom = productos.Average(p => p.Price);
        Console.WriteLine($"Precio promedio: {prom:0.00} EUR");
    }
}

TL;DR

Artículos relacionados