CodeGym /Cursos /C# SELF /Combinando expresiones lambda y delegados

Combinando expresiones lambda y delegados

C# SELF
Nivel 50, Lección 4
Disponible

1. Introducción

Delegado — es un tipo que describe la "firma" de una función: qué parámetros acepta y qué devuelve. Es como el pasaporte de una función o el pase de un club nocturno para el código: si la firma coincide — pasas; si no coincide — lo siento, no entras.

Ejemplo:

public delegate int Operation(int a, int b);

Este delegado representa una función que toma dos int y devuelve un int. Así se programaba "antes de las lambdas" (curioso, pero poco cómodo):

Operation add = delegate (int x, int y)
{
    return x + y;
};

Con la llegada de las lambdas el código quedó más conciso:

Operation add = (x, y) => x + y;

Dato interesante: En C# una expresión lambda es simplemente una forma de crear una "función anónima" que se compila automáticamente en una instancia de un delegado del tipo adecuado. Y así la relación entre ambos se vuelve prácticamente indistinguible.

Delegados integrados: Func, Action, Predicate

Para no crear delegados personalizados para cada caso, en C# existen tipos "genéricos" para funciones:

  • Func<T1, T2, ..., TResult> — delegado genérico que acepta parámetros (T1, T2, ...) y devuelve un valor de tipo TResult.
  • Action<T1, T2, ...> — casi igual, pero no devuelve nada (void).
  • Predicate<T> — delegado genérico que acepta un parámetro y devuelve bool (el favorito de todos los "filtros").
Delegado Tipo devuelto Ejemplo de sintaxis
Func<int, int>
int
Func<int, int> f = x => x + 1;
Action<string>
void
Action<string> a = s => ...;
Predicate<double>
bool
Predicate<double> p = d => ...;

Ejemplo:

Func<int, int, int> add = (a, b) => a + b;
Action<string> show = s => Console.WriteLine(s);
Predicate<int> isEven = n => n % 2 == 0;

2. Expresiones lambda "envueltas" en delegados

Pasar una lambda a un método que espera un delegado

Cualquier método que acepta un delegado puede "comerse" una lambda, si su firma coincide con la esperada.

public static void CalculateAndShow(int a, int b, Func<int, int, int> operation)
{
    int result = operation(a, b);
    Console.WriteLine($"Resultado: {result}");
}

// Llamamos con una lambda
CalculateAndShow(5, 7, (x, y) => x * y); // Resultado: 35

Ejemplo con Action

void ProcessString(string message, Action<string> processor)
{
    processor(message);
}

// Usamos una lambda
ProcessString("¡Hola, mundo!", s => Console.WriteLine(s.ToUpper()));

Ejemplo con Predicate

List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
List<int> evenNumbers = numbers.FindAll(n => n % 2 == 0);

En esos momentos entiendes: ¿para qué inventar delegados a mano si ya hay una rueda probada por Microsoft?

Cómo trabajan delegados y lambdas juntos

flowchart TD
    A[Expresión lambda] -->|Crea| B((Delegado))
    B -->|Se pasa como argumento| C[Método]
    B -->|Se guarda| D[Propiedad/Campo/Colección]
    C -->|Invoca| E[Código de la lambda]

3. Pasar una lambda como delegado en tus propios métodos

Si tu propio método usa delegados, la lambda hace que el uso sea muy flexible.

Ejemplo: nuestra mini-calculadora

// Definimos un método para trabajar con operaciones
static int PerformOperation(int a, int b, Func<int, int, int> operation)
{
    return operation(a, b);
}

// Aplicamos distintas operaciones (¡lambdas en acción!)
int sum = PerformOperation(3, 4, (x, y) => x + y);
int multiply = PerformOperation(3, 4, (x, y) => x * y);
int max = PerformOperation(3, 4, (x, y) => x > y ? x : y);

Console.WriteLine(sum);      // 7
Console.WriteLine(multiply); // 12
Console.WriteLine(max);      // 4

¿Ves cómo cambia la lógica de forma elegante, en vez de tener tres métodos separados?

4. Lambdas + delegados en LINQ (y no solo)

En LINQ los métodos esperan una "mini-función lógica", es decir, justo un delegado. Casi todos los métodos estándar de LINQ aceptan estos tipos:

  • Func<T, bool> para filtrar (Where)
  • Func<T, TResult> para transformaciones (Select)
  • Func<T, TKey> para ordenaciones (OrderBy)
List<string> names = new List<string> { "Ana", "Oleg", "Víctor", "Yana" };

// Obtenemos solo los nombres de más de 3 caracteres
var longNames = names.Where(name => name.Length > 3);

// Transformamos los nombres a mayúsculas
var upperNames = names.Select(name => name.ToUpper());

LINQ es "lambdas a tope", porque todo lo que puedas pasar como delegado lo puedes pasar como lambda.

5. Combinación: almacenamiento y paso de delegados-lambda

Lista de funciones

Una lambda no es solo un método anónimo temporal. Puedes guardar un conjunto de lambdas en una colección y usarlas dinámicamente.

List<Func<int, int, int>> operations = new List<Func<int, int, int>>
{
    (x, y) => x + y,
    (x, y) => x - y,
    (x, y) => x * y,
    (x, y) => x / y
};

foreach (var op in operations)
{
    Console.WriteLine(op(10, 2));
}

Este patrón aparece mucho en tests, handlers y plugins.

Diccionario de delegados

Y si eres fan de arquitecturas plug-and-play:

var mathFuncs = new Dictionary<string, Func<int, int, int>>
{
    { "plus", (x, y) => x + y },
    { "minus", (x, y) => x - y },
    { "pow", (x, y) => (int)Math.Pow(x, y) }
};

string command = "pow"; // Simulación de entrada del usuario

if (mathFuncs.TryGetValue(command, out var operation))
{
    Console.WriteLine(operation(2, 5)); // 32
}
else
{
    Console.WriteLine("Comando no encontrado");
}

6. Matices útiles

Delegados-lambda: devolver un delegado desde un método

Puedes devolver delegados (y por lo tanto lambdas) desde métodos — sale casi una fábrica de funciones.

Func<int, int> GetMultiplier(int factor)
{
    // Devolvemos un delegado-lambda que multiplicará por factor
    return x => x * factor;
}

var triple = GetMultiplier(3);
Console.WriteLine(triple(5)); // 15

var quadruple = GetMultiplier(4);
Console.WriteLine(quadruple(5)); // 20

Así el closure deja de ser un juguete y se convierte en una herramienta real.

Composición de funciones: Combine, Delegate.Combine y multidelegados

A veces quieres que una sola "invocación" ejecute varias funciones. Por ejemplo, en el manejo de eventos de una GUI: pulsas un botón y varios manejadores reaccionan.

Action y los delegados permiten "encadenar" varias funciones:

Action<string> pipeline = s => Console.WriteLine("Paso 1: " + s);
pipeline += s => Console.WriteLine("Paso 2: " + s.ToUpper());
pipeline += s => Console.WriteLine("Paso 3: " + s.Length);

pipeline("test");
// Muestra:
// Paso 1: test
// Paso 2: TEST
// Paso 3: 4

Útil para escenarios de "cadenas" o para manejar eventos.

Importante: Para funciones que devuelven valores, el resultado será solo del último llamado (la "cola" de la función). Para Action — se ejecutan todas, ya que devuelven void.

Usar delegados-lambda como parámetros callback

Escenario clásico: "llámame cuando termines".

void DownloadFile(string url, Action<string> onFinish)
{
    // Simulación de descarga de archivo...
    System.Threading.Thread.Sleep(500);// (Simulación de trabajo largo, no usar en GUI reales)
    onFinish($"Descarga '{url}' completada!");
}

DownloadFile("http://example.com", msg => Console.WriteLine(msg));

En aplicaciones reales (por ejemplo, al trabajar con APIs, bases de datos, archivos) — es un patrón estándar.

Función de orden superior: ejemplo de filtro por predicado

Las lambdas y los delegados te permiten escribir funciones genéricas que aceptan otras funciones como parámetros. Es la base del patrón "función de orden superior".

List<int> Filter(List<int> source, Predicate<int> condition)
{
    List<int> result = new List<int>();
    foreach (var item in source)
        if (condition(item)) result.Add(item);
    return result;
}

// Usamos distintas lambdas:
var onlyPositive = Filter(new List<int> { -2, 0, 2, 7 }, x => x > 0);
var onlyEven = Filter(new List<int> { -2, 0, 2, 7 }, x => x % 2 == 0);

Incluso puedes crear "fábricas" de lambdas:

Func<int, Predicate<int>> GetRangeChecker(int min, int max) =>
    x => x >= min && x <= max;

Predicate<int> inRange = GetRangeChecker(1, 10);

var filtered = Filter(new List<int> { 0, 5, 10, 15 }, inRange); // 5, 10

7. Errores típicos y matices de la combinación

Si la firma de los parámetros no coincide, el compilador se quejará (CS1660: "Cannot convert lambda expression").

Una lambda puede inesperadamente "recordar" variables que luego cambian (closure) — ten cuidado con la captura de variables.

Los multidelegados con valor de retorno devuelven el resultado solo del último manejador — suele ser una sorpresa para los principiantes.

En contextos donde se necesitan expresiones Expression<Func<int,bool>>, no puedes pasar una statement-lambda — se requiere exactamente una expression-lambda.

2
Tarea
C# SELF, nivel 50, lección 4
Bloqueada
Uso de Func y Action
Uso de Func y Action
1
Cuestionario/control
Delegados - tipo para expresiones lambda, nivel 50, lección 4
No disponible
Delegados - tipo para expresiones lambda
Relación entre expresiones lambda y delegados
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION