मुझे Func<T>बहुत उपयोगी लगता है जब मैं एक घटक बनाता हूं जिसे "मक्खी पर" व्यक्तिगत होने की आवश्यकता होती है।
यह एक बहुत ही सरल उदाहरण लें: एक PrintListToConsole<T>घटक।
एक बहुत ही सरल वस्तु जो वस्तुओं की इस सूची को कंसोल पर प्रिंट करती है। आप डेवलपर को इसका उपयोग करने देना चाहते हैं जो आउटपुट को निजीकृत करता है।
उदाहरण के लिए, आप उसे एक विशेष प्रकार के संख्या प्रारूप आदि को परिभाषित करने देना चाहते हैं।
फंक के बिना
सबसे पहले, आपको एक वर्ग के लिए एक इंटरफ़ेस बनाना होगा जो इनपुट लेता है और कंसोल को प्रिंट करने के लिए स्ट्रिंग पैदा करता है।
interface PrintListConsoleRender<T> {
String Render(T input);
}
फिर आपको उस वर्ग को बनाना होगा PrintListToConsole<T>जो पहले बनाए गए इंटरफ़ेस को लेता है और सूची के प्रत्येक तत्व पर इसका उपयोग करता है।
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));
}
}
}
डेवलपर को आपके घटक का उपयोग करने की आवश्यकता है:
इंटरफ़ेस लागू करें
वास्तविक कक्षा पास करें 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();
}
}
फंक का उपयोग करना बहुत सरल है
घटक के अंदर आप प्रकार का एक पैरामीटर को परिभाषित Func<T,String>है कि एक समारोह के लिए एक इंटरफेस का प्रतिनिधित्व करता है कि प्रकार टी के एक इनपुट पैरामीटर लेता है और एक स्ट्रिंग (कंसोल के लिए उत्पादन) रिटर्न
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));
}
}
}
जब डेवलपर आपके घटक का उपयोग करता है तो वह केवल घटक के कार्यान्वयन के लिए पास Func<T, String>करता है, यह एक ऐसा फ़ंक्शन है जो कंसोल के लिए आउटपुट बनाता है।
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>आपको मक्खी पर एक सामान्य विधि इंटरफ़ेस को परिभाषित करने देता है।
आप परिभाषित करते हैं कि इनपुट किस प्रकार का है और आउटपुट किस प्रकार का है। सरल और संक्षिप्त।