Func vs. action vs. prédicat

Question

Avec des exemples réels et leur utilisation, quelqu'un peut-il m'aider à comprendre :

1. Quand avons-nous besoin d'un Func<T, ..> délégué ?
2. Quand avons-nous besoin d'un Action<T> délégué ?
3. Quand avons-nous besoin d'un Predicate<T> délégué ?

Answer 1

La différence entre Func y Action est simplement de savoir si vous voulez que le délégué retourne une valeur (utiliser Func ) ou non (utiliser Action ).

Func est probablement le plus utilisé dans LINQ - par exemple dans les projections :

 list.Select(x => x.SomeProperty)

ou le filtrage :

 list.Where(x => x.SomeValue == someOtherValue)

ou la sélection d'une touche :

 list.Join(otherList, x => x.FirstKey, y => y.SecondKey, ...)

Action est plus communément utilisé pour des choses comme List<T>.ForEach : exécuter l'action donnée pour chaque élément de la liste. Je l'utilise moins souvent que Func bien que je faire utilisent parfois la version sans paramètre pour des choses comme Control.BeginInvoke y Dispatcher.BeginInvoke .

Predicate est juste un boîtier spécial Func<T, bool> vraiment, introduit avant tous les Func et la plupart des Action les délégués sont arrivés. Je soupçonne que si nous avions déjà eu Func y Action sous leurs différentes formes, Predicate n'aurait pas été introduite... bien qu'elle fait confèrent un certain sens à l'utilisation du délégué, alors que Func y Action sont utilisés à des fins très différentes.

Predicate est surtout utilisé dans List<T> pour des méthodes comme FindAll y RemoveAll .

Answer 2

Action est un délégué (pointeur) vers une méthode, qui prend zéro, un ou plusieurs paramètres d'entrée, mais ne renvoie rien.

Func est un délégué (pointeur) vers une méthode, qui prend zéro, un ou plusieurs paramètres d'entrée, et renvoie une valeur (ou une référence).

Prédicat est un type spécial de Func souvent utilisé pour les comparaisons (prend un paramètre générique et retourne un bool).

Bien que largement utilisés avec Linq, Action et Func sont des concepts logiquement indépendants de Linq. C++ contenait déjà le concept de base sous la forme de pointeurs de fonctions typés.

Voici un petit exemple pour Action et Func sans utiliser Linq :

class Program
{
    static void Main(string[] args)
    {
        Action<int> myAction = new Action<int>(DoSomething);
        myAction(123);           // Prints out "123"
                                 // can be also called as myAction.Invoke(123);

        Func<int, double> myFunc = new Func<int, double>(CalculateSomething);
        Console.WriteLine(myFunc(5));   // Prints out "2.5"
    }

    static void DoSomething(int i)
    {
        Console.WriteLine(i);
    }

    static double CalculateSomething(int i)
    {
        return (double)i/2;
    }
}

Answer 3

Func - Lorsque vous voulez un délégué pour une fonction qui peut ou non prendre des paramètres et retourner une valeur. L'exemple le plus courant serait Select de LINQ :

var result = someCollection.Select( x => new { x.Name, x.Address });

Action - Lorsque vous voulez un délégué pour une fonction qui peut ou non prendre des paramètres et ne renvoie pas de valeur. Je les utilise souvent pour les gestionnaires d'événements anonymes :

button1.Click += (sender, e) => { /* Do Some Work */ }

Prédicat - Lorsque vous voulez une version spécialisée d'un Func qui évalue une valeur par rapport à un ensemble de critères et renvoie un résultat booléen (vrai pour une correspondance, faux sinon). Encore une fois, ceux-ci sont utilisés dans LINQ assez fréquemment pour des choses comme Where :

~~var filteredResults = someCollection.Where(x => x.someCriteriaHolder == someCriteria);~~

Je viens de vérifier et il s'avère que LINQ n'utilise pas de prédicats. Je ne sais pas trop pourquoi ils ont pris cette décision... mais théoriquement, c'est toujours une situation où un prédicat pourrait convenir.