1. Introducción
Imagina que tienes una cafetera. Normalmente solo hace el café y ya, pero a veces el jefe dice: «¿Podrías, por favor, después de preparar el café gritar «¡Listo!»?» — y ahí hace falta configurar algo. No reescribimos la cafetera: simplemente creamos una función que ejecute al final.
En C# ese papel lo hacen los delegados: permiten pasar a los métodos trozos de código (métodos, lambdas o métodos anónimos) para que ese método los invoque en el momento adecuado. En términos simples, un delegado es un tipo que puede almacenar referencias a métodos con una firma determinada.
Definición de delegado
En C# un delegado se define con la palabra clave delegate. Ejemplo:
// Delegado que hace referencia a métodos que aceptan int y devuelven bool
public delegate bool PredicateInt(int x);
Ahora una variable de tipo PredicateInt podrá referirse a cualquier método (¡o lambda!) que reciba un int y devuelva un bool.
¿Para qué sirven los delegados?
- Pasar lógica como argumento (por ejemplo, para ordenar, filtrar, manejar eventos)
- Suscribirse a eventos (de esto hablaremos más adelante)
- Implementar callbacks
- APIs flexibles donde parte del comportamiento lo define quien llama
Esquema visual simple
| Tipo de delegado | Firma | Ejemplo de uso |
|---|---|---|
|
|
|
|
|
|
|
|
|
2. Cómo una lambda se convierte en delegado
Sintaxis
Cuando escribes una expresión lambda, por ejemplo x => x > 5, en esencia estás creando un objeto delegado. La lambda no «vive» en el vacío: necesita un tipo (alguien tiene que saber su conjunto de parámetros y el resultado). Por eso la expresión lambda en C# siempre se convierte, implícita o explícitamente, en un delegado.
Ejemplo 1: Asignar una lambda a un delegado
// Declaramos el delegado explícitamente
public delegate bool MyPredicate(int number);
class Program
{
static void Main()
{
// Asignamos la lambda a una variable de tipo MyPredicate
MyPredicate isEven = x => x % 2 == 0;
Console.WriteLine(isEven(4)); // true
Console.WriteLine(isEven(7)); // false
}
}
Ejemplo 2: Uso de los delegados estándar
C# tiene un conjunto de delegados genéricos estándar: Action, Func<>, Predicate<>. Se usan casi siempre donde escribes lambdas en el código.
// Usando Func<int, bool>
Func<int, bool> isPositive = number => number > 0;
Console.WriteLine(isPositive(-5)); // false
3. Delegados estándar: Func, Action, Predicate
Func<...>
Se usa para métodos que aceptan parámetros y devuelven algo.
Firma:
— El último tipo es el valor devuelto; los anteriores son los parámetros, por ejemplo:
Func<int, string> — acepta int, devuelve string
Func<int, string> intToString = number => "Número: " + number;
Console.WriteLine(intToString(7)); // "Número: 7"
Action<...>
Se usa cuando quieres ejecutar algo y no devolver nada (void).
Action<string> printHello = name => Console.WriteLine("¡Hola, " + name + "!");
printHello("John"); // "¡Hola, John!"
Predicate<T>
Básicamente es un alias para Func<T, bool>. Se usa cuando necesitas una comprobación booleana sobre un objeto (true/false).
Predicate<int> isOdd = x => x % 2 != 0;
Console.WriteLine(isOdd(3)); // true
Chuleta visual
| Delegado | Firma | Uso |
|---|---|---|
|
|
Transformación, proyección |
|
|
Efectos secundarios, salida |
|
|
Filtrado, búsqueda |
¿Qué tipo de delegado elegir para una lambda?
- Si se espera un valor devuelto, usa Func<...>
- Si el método no devuelve nada (void), usa Action<...>
- Si necesitas una comprobación, usa Predicate<T>
Ejemplo: Filtrar una lista
List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6 };
// Espera Predicate<int>
List<int> evenNumbers = numbers.FindAll(x => x % 2 == 0);
Console.WriteLine(string.Join(", ", evenNumbers)); // 2, 4, 6
4. Detalles útiles
Expresiones lambda y métodos de colecciones: ¿qué pasa por debajo?
Cuando llamas a un método de colección pasando una lambda, por ejemplo:
var adults = users.Where(u => u.Age >= 18);
El método Where espera un argumento de tipo Func<T, bool>. Es decir, tu lambda u => u.Age >= 18 la convierte el compilador en un objeto delegado de ese tipo.
Diagrama: cómo funciona
Tu lambda --> Compilador de C# --> Objeto delegado (Func<T, bool>)
(u => u.Age >= 18) [tipo conocido] (Listo para ser invocado en Where())
Más sobre tipado: inferencia de tipos
Normalmente el tipo del delegado lo inferirá el compilador automáticamente si el contexto es claro. Por ejemplo, para el método List<T>.Find se espera un Predicate<T>, y el compilador ya sabe el tipo del parámetro por la firma del método.
List<string> words = new List<string> { "one", "two", "three" };
var result = words.Find(word => word.Length == 5); // Find espera Predicate<string>
Console.WriteLine(result); // "three"
Si el contexto no es claro, tendrás que ayudar al compilador:
// Especificamos el tipo explícitamente
Func<int, bool> check = x => x > 10;
Delegados devueltos: fábricas de funciones
A veces los métodos pueden devolver delegados — es decir, crear "fábricas de funciones". Es útil para generar comportamiento dinámico.
// Función que devuelve un delegado (lambda)
Func<int, int> GetMultiplier(int factor)
{
return x => x * factor;
}
var times3 = GetMultiplier(3);
Console.WriteLine(times3(5)); // 15
Funciona porque la lambda (x => x * factor) captura la variable factor del contexto externo (closure/captura) y se devuelve como un objeto de tipo Func<int, int>.
5. Errores y malentendidos con delegados y lambdas
Desajuste de firmas
El compilador no permitirá asignar una lambda a un delegado si los parámetros o el valor devuelto no coinciden.
Func<int, int> f = x => "¡No se puede devolver una cadena!"; // Error de compilación
Error al intentar usar una lambda sin delegado
No puedes simplemente escribir una lambda e intentar invocarla sin tipo:
// Esto no funcionará: el compilador no puede inferir el tipo
// var myFunc = x => x * 2; // Error CS0815
// myFunc(10);
Para que funcione, hay que indicar el tipo explícitamente o dar contexto:
Func<int, int> myFunc = x => x * 2;
Console.WriteLine(myFunc(10)); // 20
Confusión entre Action, Func y Predicate
A veces se elige el tipo equivocado y aparece un error de firma. Recuerda la regla simple: Func — cuando hay resultado, Action — cuando no hay resultado (void), Predicate<T> — cuando necesitas respuesta lógica (bool).
GO TO FULL VERSION