Che cos'è Predicate in C#?

Un tipo delegate che accetta un T e restituisce bool, la stessa forma di Func . È precedente a Func ed è usato da List .Find, FindAll, RemoveAll, Exists e Array.Find. I due tipi non si convertono l'uno nell'altro, ma una lambda si converte in entrambi.

Guida C# interattiva: Func e Action

Q: Che differenza c'è tra Func e Action in C#?

Func restituisce un valore e Action no. In Func , l'ultimo argomento di tipo (bool) è il tipo di ritorno e gli altri sono parametri. Action accetta un int e una string e restituisce void. Entrambi esistono in versioni da 0 a 16 parametri.

Q: Come passo una funzione come parametro in C#?

Dichiara il parametro come Func o Action della forma giusta e chiamalo dentro il metodo: static decimal Apply(decimal price, Func rule) => rule(price);. Chi chiama passa una lambda (Apply(80m, p => p * 0.9m)) o il nome di un metodo (Apply(80m, HalfPrice)).

Q: Come uso Func con il codice async?

Usa Func per una funzione async senza risultato e Func > per una con risultato, così chi chiama può fare await. Evita di assegnare una lambda async a un Action: diventa async void, che non si può attendere e le cui eccezioni non possono essere catturate da chi chiama.

Q: Func può avere parametri out o ref?

No. I parametri generici di Func e Action sono normali parametri per valore, quindi non c'è modo di scrivere Func . Per una firma come TryParse, dichiara un delegate personalizzato: delegate bool TryParser (string text, out T value);.

Func e Action sono tipi delegate generici che .NET dichiara al posto tuo, così puoi memorizzare e passare funzioni senza dichiarare prima un tipo delegate. Func restituisce un valore; Action non restituisce niente.

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);
    }
}

Output:

4
46.00
False
Hello!
Mia scored 87

La regola da ricordare: in un Func, l'ultimo argomento di tipo è il tipo di ritorno. Func<int, int, bool> accetta due int e restituisce un bool. Func<int> non accetta niente e restituisce un int. Gli argomenti di tipo di un Action sono tutti parametri.

La famiglia

Tipo	Parametri	Restituisce
`Action`	nessuno	`void`
`Action<T>`	`T`	`void`
`Action<T1, T2>` ... fino a 16	`T1, T2, ...`	`void`
`Func<TResult>`	nessuno	`TResult`
`Func<T, TResult>`	`T`	`TResult`
`Func<T1, T2, TResult>` ... fino a 16	`T1, T2, ...`	`TResult`
`Predicate<T>`	`T`	`bool`
`Comparison<T>`	`T, T`	`int` (negativo, zero, positivo)
`Converter<TIn, TOut>`	`TIn`	`TOut`

Predicate, Comparison e Converter sono più vecchi e compaiono nei metodi di List<T> e Array: FindAll(Predicate<T>), Sort(Comparison<T>), ConvertAll(Converter<T, TOut>). LINQ usa Func ovunque, ed è per questo che list.Where(...) e list.FindAll(...) accettano lambda della stessa forma ma di tipi diversi:

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));
    }
}

Output:

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

Passare funzioni ai metodi

Un parametro Func o Action permette a chi chiama di fornire la parte di un algoritmo che cambia. Due forme comuni sono "esegui questo e misuralo" e "prova questo finché non funziona":

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}");
    }
}

Output:

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

Retry è generico, quindi il suo Func<int, T> può restituire qualsiasi cosa; il compilatore ha dedotto T come string dalla lambda. La lambda passata a Twice modifica la variabile locale clicks, e funziona perché una lambda cattura la variabile stessa, non una copia del suo valore.

Method group: passare un metodo per nome

Non ti serve una lambda per riempire un Func o un Action. Il nome di un metodo esistente con una firma compatibile (un "method group") si converte direttamente:

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}");
    }
}

Output:

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

Select(int.Parse) equivale a Select(s => int.Parse(s)), con un livello di chiamata in meno. Il compilatore sceglie l'overload adatto al tipo di destinazione: int.Parse ha diversi overload, e solo Parse(string) corrisponde a Func<string, int>. Quando il compilatore non riesce a sceglierne uno (più overload vanno bene allo stesso modo, o gli argomenti di tipo di un metodo generico non si possono dedurre da un method group), la chiamata non compila, e una lambda che rende esplicita la chiamata risolve il problema.

Un method group usato come Func viene comunque eseguito più tardi, ogni volta che il delegate viene invocato, esattamente come una lambda. La differenza sta solo in come si scrive.

Restituire funzioni

Un metodo può costruire e restituire una funzione. Il Func restituito porta con sé i valori da cui è stato costruito:

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));
    }
}

Output:

140
180
162

Twice(staff) costruisce una nuova funzione che applica due volte lo sconto per il personale: 200, poi 180, poi 162.

Un dizionario di funzioni

Memorizzare funzioni in un dizionario trasforma un lungo switch in una tabella di ricerca. È la forma abituale per gestori di comandi, calcolatrici e azioni di menu, e si possono aggiungere nuove voci a runtime:

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");
    }
}

Output:

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

Aggiungere un operatore significa aggiungere una voce al dizionario, senza toccare il ciclo. Lo StringComparer.OrdinalIgnoreCase passato al secondo dizionario rende i nomi dei comandi insensibili a maiuscole e minuscole.

Funzioni async: Func<Task>, non Action

Con il codice async, il tipo delegate decide se chi chiama può attendere il lavoro:

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 assegnata a un Action diventa un metodo async void: niente può attenderla, e un'eccezione al suo interno non arriva mai a chi chiama. Viene rilanciata sul thread pool (o sul thread dell'interfaccia in un'app desktop), dove di solito fa terminare il processo. Quando scrivi un metodo che accetta lavoro asincrono, prendi un Func<Task> (o Func<Task<T>>).

Quando dichiarare un delegate tuo

Func e Action coprono la maggior parte delle esigenze. Dichiara un tipo delegate con nome quando:

La firma ha parametri ref, out o in. Func non può esprimerli, quindi una funzione in stile TryParse richiede delegate bool TryParser<T>(string text, out T value);.
Il nome documenta un ruolo in un'API pubblica. delegate bool Validator(string input) nella firma di un metodo dice più di Func<string, bool>, e i nomi dei suoi parametri compaiono in IntelliSense.
Ti serve un parametro params, che anche i delegate generici non possono avere.

Gli eventi sono l'altro posto in cui compaiono ancora tipi delegate personalizzati, anche se l'EventHandler<TEventArgs> integrato copre la maggior parte dei casi. La pagina sui delegate spiega come dichiarare e combinare i tipi delegate.

Domande frequenti

Che differenza c'è tra Func e Action in C#?

Func restituisce un valore e Action no. In Func<int, string, bool>, l'ultimo argomento di tipo (bool) è il tipo di ritorno e gli altri sono parametri. Action<int, string> accetta un int e una string e restituisce void. Entrambi esistono in versioni da 0 a 16 parametri.

Come passo una funzione come parametro in C#?

Dichiara il parametro come Func o Action della forma giusta e chiamalo dentro il metodo: static decimal Apply(decimal price, Func<decimal, decimal> rule) => rule(price);. Chi chiama passa una lambda (Apply(80m, p => p * 0.9m)) o il nome di un metodo (Apply(80m, HalfPrice)).

Che cos'è Predicate<T> in C#?

Un tipo delegate che accetta un T e restituisce bool, la stessa forma di Func<T, bool>. È precedente a Func ed è usato da List<T>.Find, FindAll, RemoveAll, Exists e Array.Find. I due tipi non si convertono l'uno nell'altro, ma una lambda si converte in entrambi.

Come uso Func con il codice async?

Usa Func<Task> per una funzione async senza risultato e Func<T, Task<TResult>> per una con risultato, così chi chiama può fare await. Evita di assegnare una lambda async a un Action: diventa async void, che non si può attendere e le cui eccezioni non possono essere catturate da chi chiama.

Func può avere parametri out o ref?

No. I parametri generici di Func e Action sono normali parametri per valore, quindi non c'è modo di scrivere Func<string, out int, bool>. Per una firma come TryParse, dichiara un delegate personalizzato: delegate bool TryParser<T>(string text, out T value);.

Concetti correlati