¿Qué es Predicate en C#?

Un tipo delegado que recibe un T y devuelve bool, con la misma forma que Func . Es anterior a Func y lo usan List .Find, FindAll, RemoveAll, Exists y Array.Find. Los dos tipos no se convierten entre sí, pero una lambda se convierte a cualquiera de ellos.

Docs ejecutables de C#: Func y Action

Q: ¿Qué diferencia hay entre Func y Action en C#?

Func devuelve un valor y Action no. En Func , el último argumento de tipo (bool) es el tipo de retorno y los demás son parámetros. Action recibe un int y un string y devuelve void. Los dos existen en versiones de 0 a 16 parámetros.

Q: ¿Cómo paso una función como parámetro en C#?

Declara el parámetro como un Func o un Action de la forma adecuada y llámalo dentro del método: static decimal Apply(decimal price, Func rule) => rule(price);. Quien llama pasa una lambda (Apply(80m, p => p * 0.9m)) o el nombre de un método (Apply(80m, HalfPrice)).

Q: ¿Cómo uso Func con código async?

Usa Func para una función async sin resultado y Func > para una con resultado, de modo que quien llama pueda hacer await. Evita asignar una lambda async a un Action: eso la convierte en async void, que no se puede esperar y cuyas excepciones no puede capturar quien llama.

Q: ¿Puede Func tener parámetros out o ref?

No. Los parámetros genéricos de Func y Action son parámetros por valor normales, así que no hay forma de escribir Func . Para una firma como la de TryParse, declara un delegado propio: delegate bool TryParser (string text, out T value);.

Func y Action son tipos delegados genéricos que .NET declara por ti, así que puedes guardar y pasar funciones sin declarar antes un tipo delegado. Func devuelve un valor; Action no devuelve nada.

using System;

class Program
{
    static void Main()
    {
        Func<int> rollFixed = () => 4;
        Func<decimal, decimal> addTip = bill => bill * 1.15m;
        Func<int, int, bool> canAfford = (budget, price) => budget >= price;

        Action greet = () => Console.WriteLine("Hello!");
        Action<string, int> report = (name, score) => Console.WriteLine($"{name} scored {score}");

        Console.WriteLine(rollFixed());
        Console.WriteLine(addTip(40m));
        Console.WriteLine(canAfford(100, 120));
        greet();
        report("Mia", 87);
    }
}

Salida:

4
46.00
False
Hello!
Mia scored 87

La regla que hay que recordar: en un Func, el último argumento de tipo es el tipo de retorno. Func<int, int, bool> recibe dos int y devuelve un bool. Func<int> no recibe nada y devuelve un int. En un Action, todos los argumentos de tipo son parámetros.

La familia

Tipo	Parámetros	Devuelve
`Action`	ninguno	`void`
`Action<T>`	`T`	`void`
`Action<T1, T2>` ... hasta 16	`T1, T2, ...`	`void`
`Func<TResult>`	ninguno	`TResult`
`Func<T, TResult>`	`T`	`TResult`
`Func<T1, T2, TResult>` ... hasta 16	`T1, T2, ...`	`TResult`
`Predicate<T>`	`T`	`bool`
`Comparison<T>`	`T, T`	`int` (negativo, cero, positivo)
`Converter<TIn, TOut>`	`TIn`	`TOut`

Predicate, Comparison y Converter son más antiguos y aparecen en métodos de List<T> y de Array: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ usa Func en todas partes, por eso list.Where(...) y list.FindAll(...) reciben lambdas de la misma forma pero de tipos distintos:

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        var ages = new List<int> { 34, 17, 52, 15, 28 };

        Predicate<int> isMinor = a => a < 18;
        Func<int, bool> isAdult = a => a >= 18;
        Comparison<int> descending = (x, y) => y.CompareTo(x);

        Console.WriteLine(string.Join(", ", ages.FindAll(isMinor)));
        Console.WriteLine(string.Join(", ", ages.Where(isAdult)));

        ages.Sort(descending);
        Console.WriteLine(string.Join(", ", ages));

        List<string> labels = ages.ConvertAll(a => $"{a}y");
        Console.WriteLine(string.Join(" ", labels));
    }
}

Salida:

17, 15
34, 52, 28
52, 34, 28, 17, 15
52y 34y 28y 17y 15y

Pasar funciones a métodos

Un parámetro Func o Action permite que quien llama aporte la parte de un algoritmo que cambia. Dos formas habituales son "ejecuta esto y mídelo" y "prueba esto hasta que funcione":

using System;

class Program
{
    static T Retry<T>(Func<int, T> attempt, int maxTries)
    {
        for (int i = 1; i <= maxTries; i++)
        {
            try
            {
                return attempt(i);
            }
            catch (InvalidOperationException)
            {
                Console.WriteLine($"attempt {i} failed");
            }
        }
        throw new InvalidOperationException("all attempts failed");
    }

    static void Twice(Action work)
    {
        work();
        work();
    }

    static void Main()
    {
        string page = Retry(n =>
        {
            if (n < 3) throw new InvalidOperationException();
            return "<html>ok</html>";
        }, maxTries: 5);
        Console.WriteLine(page);

        int clicks = 0;
        Twice(() => clicks++);
        Console.WriteLine($"clicks: {clicks}");
    }
}

Salida:

attempt 1 failed
attempt 2 failed
<html>ok</html>
clicks: 2

Retry es genérico, así que su Func<int, T> puede devolver cualquier cosa; el compilador dedujo T como string a partir de la lambda. La lambda que se pasa a Twice cambia la variable local clicks, y funciona porque una lambda captura la propia variable, no una copia de su valor.

Grupos de métodos: pasar un método por su nombre

No necesitas una lambda para rellenar un Func o un Action. El nombre de un método existente con una firma compatible (un "grupo de métodos") se convierte directamente:

using System;
using System.Linq;

class Program
{
    static bool IsWeekendCode(string day) => day == "sat" || day == "sun";

    static void Main()
    {
        Func<string, int> parse = int.Parse;
        Func<string, bool> weekend = IsWeekendCode;
        Action<string> print = Console.WriteLine;

        string[] quantities = { "3", "10", "7" };
        int total = quantities.Select(int.Parse).Sum();

        print($"parsed: {parse("42") + 1}");
        print($"sat is weekend: {weekend("sat")}");
        print($"total quantity: {total}");
    }
}

Salida:

parsed: 43
sat is weekend: True
total quantity: 20

Select(int.Parse) es lo mismo que Select(s => int.Parse(s)), con una capa de llamada menos. El compilador elige la sobrecarga que encaja con el tipo de destino: int.Parse tiene varias sobrecargas, y solo Parse(string) coincide con Func<string, int>. Cuando el compilador no puede decidirse por una (varias sobrecargas encajan igual de bien, o los argumentos de tipo de un método genérico no pueden deducirse de un grupo de métodos), la llamada no compila, y una lambda que haga explícita la llamada lo resuelve.

Un grupo de métodos usado como Func sigue ejecutándose más tarde, cada vez que se invoca el delegado, exactamente igual que una lambda. La diferencia está solo en cómo se escribe.

Devolver funciones

Un método puede construir y devolver una función. El Func devuelto lleva consigo los valores a partir de los que se construyó:

using System;

class Program
{
    static Func<decimal, decimal> PercentOff(decimal percent) =>
        price => price - price * percent / 100m;

    static Func<T, T> Twice<T>(Func<T, T> f) => x => f(f(x));

    static void Main()
    {
        Func<decimal, decimal> blackFriday = PercentOff(30m);
        Func<decimal, decimal> staff = PercentOff(10m);

        Console.WriteLine(blackFriday(200m));
        Console.WriteLine(staff(200m));
        Console.WriteLine(Twice(staff)(200m));
    }
}

Salida:

140
180
162

Twice(staff) construye una función nueva que aplica dos veces el descuento de empleado: 200, después 180 y después 162.

Un diccionario de funciones

Guardar funciones en un diccionario convierte un switch largo en una tabla de búsqueda. Es la forma habitual de los manejadores de comandos, las calculadoras y las acciones de menú, y se pueden añadir entradas nuevas en tiempo de ejecución:

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var operations = new Dictionary<string, Func<decimal, decimal, decimal>>
        {
            ["+"] = (a, b) => a + b,
            ["-"] = (a, b) => a - b,
            ["*"] = (a, b) => a * b,
            ["/"] = (a, b) => b == 0 ? throw new DivideByZeroException() : a / b,
        };

        var commands = new Dictionary<string, Action<string>>(StringComparer.OrdinalIgnoreCase)
        {
            ["greet"] = arg => Console.WriteLine($"Hello, {arg}"),
            ["shout"] = arg => Console.WriteLine(arg.ToUpper()),
        };

        string[] inputs = { "12 + 30", "7 * 6", "9 / 0", "2 ^ 3" };
        foreach (string input in inputs)
        {
            string[] p = input.Split(' ');
            Func<decimal, decimal, decimal> op;
            if (!operations.TryGetValue(p[1], out op))
            {
                Console.WriteLine($"{input} = unknown operator");
                continue;
            }
            try
            {
                Console.WriteLine($"{input} = {op(decimal.Parse(p[0]), decimal.Parse(p[2]))}");
            }
            catch (DivideByZeroException)
            {
                Console.WriteLine($"{input} = cannot divide by zero");
            }
        }

        commands["GREET"]("Sam");
        commands["shout"]("done");
    }
}

Salida:

12 + 30 = 42
7 * 6 = 42
9 / 0 = cannot divide by zero
2 ^ 3 = unknown operator
Hello, Sam
DONE

Añadir un operador es una entrada más en el diccionario, sin cambiar el bucle. El StringComparer.OrdinalIgnoreCase que se pasa al segundo diccionario hace que los nombres de los comandos no distingan mayúsculas y minúsculas.

Funciones async: Func<Task>, no Action

Con código async, el tipo delegado decide si quien llama puede esperar al trabajo:

Func<Task> save = async () => await File.WriteAllTextAsync("a.txt", "data");
await save();                       // the caller can await it and see its exceptions

Func<int, Task<string>> load = async id => await FetchUserAsync(id);
string user = await load(42);

Action bad = async () => await File.WriteAllTextAsync("a.txt", "data");
bad();                              // async void: fire and forget, exceptions escape

Una lambda async asignada a un Action se convierte en un método async void: nada puede esperarla, y una excepción dentro de ella nunca llega a quien llama. Se vuelve a lanzar en el pool de hilos (o en el hilo de la interfaz en una aplicación de escritorio), donde normalmente hace caer el proceso. Cuando escribas un método que acepte trabajo async, recibe un Func<Task> (o Func<Task<T>>).

Cuándo declarar tu propio delegado

Func y Action cubren casi todas las necesidades. Declara un tipo delegado con nombre cuando:

La firma tiene parámetros ref, out o in. Func no puede expresarlos, así que una función al estilo de TryParse necesita delegate bool TryParser<T>(string text, out T value);.
El nombre documenta un papel en una API pública. delegate bool Validator(string input) en la firma de un método dice más que Func<string, bool>, y los nombres de sus parámetros aparecen en IntelliSense.
Necesitas un parámetro params, que los delegados genéricos tampoco pueden tener.

Los eventos son el otro sitio donde siguen apareciendo tipos delegados propios, aunque el EventHandler<TEventArgs> incorporado cubre la mayoría. La página de delegados explica cómo declarar y combinar tipos delegados.

Preguntas frecuentes

¿Qué diferencia hay entre Func y Action en C#?

Func devuelve un valor y Action no. En Func<int, string, bool>, el último argumento de tipo (bool) es el tipo de retorno y los demás son parámetros. Action<int, string> recibe un int y un string y devuelve void. Los dos existen en versiones de 0 a 16 parámetros.

¿Cómo paso una función como parámetro en C#?

Declara el parámetro como un Func o un Action de la forma adecuada y llámalo dentro del método: static decimal Apply(decimal price, Func<decimal, decimal> rule) => rule(price);. Quien llama pasa una lambda (Apply(80m, p => p * 0.9m)) o el nombre de un método (Apply(80m, HalfPrice)).

¿Qué es Predicate<T> en C#?

Un tipo delegado que recibe un T y devuelve bool, con la misma forma que Func<T, bool>. Es anterior a Func y lo usan List<T>.Find, FindAll, RemoveAll, Exists y Array.Find. Los dos tipos no se convierten entre sí, pero una lambda se convierte a cualquiera de ellos.

¿Cómo uso Func con código async?

Usa Func<Task> para una función async sin resultado y Func<T, Task<TResult>> para una con resultado, de modo que quien llama pueda hacer await. Evita asignar una lambda async a un Action: eso la convierte en async void, que no se puede esperar y cuyas excepciones no puede capturar quien llama.

¿Puede Func tener parámetros out o ref?

No. Los parámetros genéricos de Func y Action son parámetros por valor normales, así que no hay forma de escribir Func<string, out int, bool>. Para una firma como la de TryParse, declara un delegado propio: delegate bool TryParser<T>(string text, out T value);.

Conceptos relacionados