Trovo Func<T>molto utile quando creo un componente che necessita di essere personalizzato "al volo".
Prendi questo esempio molto semplice: un PrintListToConsole<T>componente.
Un oggetto molto semplice che stampa questo elenco di oggetti sulla console. Vuoi consentire allo sviluppatore che lo utilizza di personalizzare l'output.
Ad esempio, vuoi lasciargli definire un particolare tipo di formato numerico e così via.
Senza Func
Per prima cosa, devi creare un'interfaccia per una classe che prende l'input e produce la stringa da stampare sulla console.
interface PrintListConsoleRender<T> {
String Render(T input);
}
Quindi devi creare la classe PrintListToConsole<T>che prende l'interfaccia creata in precedenza e la usa su ogni elemento della lista.
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));
}
}
}
Lo sviluppatore che deve utilizzare il tuo componente deve:
implementare l'interfaccia
passare la vera classe al 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();
}
}
Usare Func è molto più semplice
All'interno del componente si definisce un parametro di tipo Func<T,String>che rappresenta un'interfaccia di una funzione che accetta un parametro di input di tipo T e restituisce una stringa (l'output per 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));
}
}
}
Quando lo sviluppatore utilizza il tuo componente passa semplicemente al componente l'implementazione del Func<T, String>tipo, cioè una funzione che crea l'output per 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>consente di definire al volo un'interfaccia di metodo generico.
Definisci il tipo di input e il tipo di output. Semplice e conciso.