Acho Func<T>muito útil quando crio um componente que precisa ser personalizado "na hora".
Veja este exemplo muito simples: um PrintListToConsole<T>componente.
Um objeto muito simples que imprime essa lista de objetos no console. Você deseja permitir que o desenvolvedor que o utiliza personalize a saída.
Por exemplo, você deseja permitir que ele defina um tipo específico de formato de número e assim por diante.
Sem Func
Primeiro, você deve criar uma interface para uma classe que recebe a entrada e produz a string para imprimir no console.
interface PrintListConsoleRender<T> {
String Render(T input);
}
Em seguida, você deve criar a classe PrintListToConsole<T>que pega a interface criada anteriormente e a usa sobre cada elemento da 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));
}
}
}
O desenvolvedor que precisa usar seu componente deve:
implementar a interface
passe a aula real para o 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();
}
}
Usar Func é muito mais simples
Dentro do componente, você define um parâmetro do tipo Func<T,String>que representa uma interface de uma função que recebe um parâmetro de entrada do tipo T e retorna uma string (a saída para o 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 o desenvolvedor usa seu componente, ele simplesmente passa para o componente a implementação do Func<T, String>tipo, que é uma função que cria a saída para o 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>permite definir uma interface de método genérico em tempo real.
Você define qual é o tipo de entrada e qual é o tipo de saída. Simples e conciso.