CodeGym /Cursos /C# SELF /Delegados como tipo para expresiones lambda

Delegados como tipo para expresiones lambda

C# SELF
Nivel 50, Lección 0
Disponible

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
Action
void()
Action act = () => ...
Func<int>
int()
Func<int> f = () => 42
Func<int, bool>
bool(int)
Func<int, bool> p = x => x > 0

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
Func<T1, TResult>
Result(T1)
Transformación, proyección
Action<T1>
void(T1)
Efectos secundarios, salida
Predicate<T>
bool(T)
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).

2
Tarea
C# SELF, nivel 50, lección 0
Bloqueada
Creación y uso de un delegado para una expresión lambda
Creación y uso de un delegado para una expresión lambda
Comentarios
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION