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 |
|---|---|---|
|
|
|
|
|
|
|
|
|
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.
GO TO FULL VERSION