Je trouve Func<T>très utile lorsque je crée un composant qui doit être personnalisé "à la volée".
Prenons cet exemple très simple: un PrintListToConsole<T>composant.
Un objet très simple qui imprime cette liste d'objets sur la console. Vous voulez laisser le développeur qui l'utilise personnaliser la sortie.
Par exemple, vous voulez lui laisser définir un type particulier de format de nombre et ainsi de suite.
Sans Func
Tout d'abord, vous devez créer une interface pour une classe qui prend l'entrée et produit la chaîne à imprimer sur la console.
interface PrintListConsoleRender<T> {
String Render(T input);
}
Ensuite, vous devez créer la classe PrintListToConsole<T>qui prend l'interface précédemment créée 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 doit:
implémenter l'interface
passer la vraie classe au 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();
}
}
Utiliser Func c'est beaucoup plus simple
À l'intérieur du composant, vous définissez un paramètre de type Func<T,String>qui représente une interface d'une fonction qui prend un paramètre d'entrée de type T et renvoie une chaîne (la sortie pour 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 transmet simplement au composant l'implémentation du Func<T, String>type, c'est-à-dire une fonction qui crée la sortie pour 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 interface de méthode générique à la volée.
Vous définissez le type de l'entrée et le type de la sortie. Simple et concis.