Qu'est-ce que la touche Func, comment et quand est-il utilisé

Func<T> est prédéfini type de délégué pour une méthode qui retourne une valeur de type T.

En d'autres termes, vous pouvez utiliser ce type de référence, une méthode qui retourne une valeur de T. E. g.

public static string GetMessage() { return "Hello world"; }

peut être référencé comme ce

Func<string> f = GetMessage;

Func<T1, T2, ..., Tn, Tr> représente une fonction, qui prend (T1, T2, ..., Tn) arguments et retourne Tr.

Par exemple, si vous avez une fonction:

double sqr(double x) { return x * x; }

Vous pouvez enregistrer comme une sorte de fonction de la variable:

Func<double, double> f1 = sqr;
Func<double, double> f2 = x => x * x;

Et ensuite utiliser exactement comme vous le feriez utiliser sqr:

f1(2);
Console.WriteLine(f2(f1(4)));

etc.

N'oubliez pas, cependant, que c'est un délégué, pour les plus avancés d'informations reportez-vous à la documentation.

Je trouve Func<T> très utile lorsque je créer un composant qui doit être personnalisés "à la volée".

Prendre cet exemple très simple: un PrintListToConsole<T> composant.

Un objet très simple qui permet d'imprimer cette liste d'objets à la console.
Vous voulez laisser le développeur qui l'utilise personnaliser la sortie.

Par exemple, vous voulez laisser à lui de définir un certain type de format de nombre et ainsi de suite.

Sans Func

Tout d'abord, vous devez créer une interface pour une classe qui prend en entrée et produit la chaîne d'imprimer à la console.

interface PrintListConsoleRender<T> {
  String Render(T input);
}

Ensuite, vous devez créer la classe PrintListToConsole<T> qui prend déjà créées interface et l'utilise sur chaque élément de la liste.

class PrintListToConsole<T> {

    private PrintListConsoleRender<T> _renderer;

    public void SetRenderer(PrintListConsoleRender<T> r) {
        //this is the point where I can personalize the render mechanism
        _renderer = r;
    }

    public void PrintToConsole(List<T> list) {
        foreach (var item in list) {
            Console.Write(_renderer.Render(item));
        }
    }   
}

Le développeur qui a besoin d'utiliser votre composant a:

1. implémenter l'interface

2. passer le cours réel de la PrintListToConsole

   class MyRenderer : PrintListConsoleRender<int> {
       public String Render(int input) {
           return "Number: " + input;
       }
   }
   
   class Program {
       static void Main(string[] args) {
           var list = new List<int> { 1, 2, 3 };
           var printer = new PrintListToConsole<int>();
           printer.SetRenderer(new MyRenderer());
           printer.PrintToConsole(list);
           string result = Console.ReadLine();   
       }   
   }

À l'aide de la touche Func c'est beaucoup plus simple

À l'intérieur de la partie, vous définissez un paramètre de type Func<T,String> que représente une interface d'une fonction qui prend un paramètre d'entrée de type T et retourne une chaîne de caractères (la sortie de la console)

class PrintListToConsole<T> {

    private Func<T, String> _renderFunc;

    public void SetRenderFunc(Func<T, String> r) {
        //this is the point where I can set the render mechanism
        _renderFunc = r;
    }

    public void Print(List<T> list) {
        foreach (var item in list) {
            Console.Write(_renderFunc(item));
        }
    }
}

Lorsque le développeur utilise votre composant, il passe simplement à la composante de la mise en œuvre de la Func<T, String> type, c'est une fonction qui crée la sortie de la console.

class Program {
    static void Main(string[] args) {
        var list = new List<int> { 1, 2, 3 }; //should be a list as the method signature expects
        var printer = new PrintListToConsole<int>();
        printer.SetRenderFunc((o) => "Number:" + o);
        printer.Print(list); 
        string result = Console.ReadLine();
    }
}

Func<T> vous permet de définir une méthode générique de l'interface à la volée.
Vous définissez quel type de l'entrée est et ce type de la sortie est.
Simple et concis.

Peut-être qu'il n'est pas trop tard pour ajouter quelques infos.

Somme:

La touche Func est un délégué personnalisé défini dans l'espace de noms System qui permet de pointer vers une méthode avec la même signature (en tant que délégués ne), à l'aide de 0 à 16 paramètres d'entrée, et qui doit retourner quelque chose.

Nomenclature & how2use:

Func<input_1, input_2, ..., input1_6, output> funcDelegate = someMethod;

Définition:

public delegate TResult Func<in T, out TResult>(T arg);

Où il est utilisé:

Il est utilisé dans les expressions lambda et les méthodes anonymes.