प्रतिनिधि और घटनाक्रम # सी में

लेख का अनुवाद विशेष रूप से पाठ्यक्रम "C # डेवलपर" के छात्रों के लिए तैयार किया गया था ।

---

C # में कौन सी घटनाएँ हैं?

एक घटना का उपयोग सूचना प्रदान करने के लिए किया जा सकता है। यदि आपको इन सूचनाओं की आवश्यकता है तो आप इस कार्यक्रम की सदस्यता ले सकते हैं। आप अपनी स्वयं की ईवेंट भी बना सकते हैं जो आपको सूचित करेगी कि आपके द्वारा किए गए कुछ हित। .NET फ्रेमवर्क अंतर्निहित प्रकार प्रदान करता है, जिनका उपयोग आप इवेंट बनाने के लिए कर सकते हैं। डेलिगेट्स, लैम्ब्डा एक्सप्रेशन और अनाम तरीकों का उपयोग करके, आप ईवेंट को सुविधाजनक तरीके से बना और उपयोग कर सकते हैं।

C # में डेलिगेट्स को समझना

C # में, प्रतिनिधि ईवेंट के लिए बुनियादी बिल्डिंग ब्लॉक बनाते हैं। एक प्रतिनिधि एक प्रकार है जो एक विधि के हस्ताक्षर को परिभाषित करता है। उदाहरण के लिए, C ++ में, यह फ़ंक्शन पॉइंटर का उपयोग करके किया जा सकता है। C # में, आप एक प्रतिनिधि का एक उदाहरण बना सकते हैं जो दूसरी विधि की ओर इशारा करता है। आप इस विधि को प्रतिनिधि उदाहरण के माध्यम से कॉल कर सकते हैं।

निम्नलिखित एक प्रतिनिधि को घोषित करने और उसके माध्यम से एक विधि को कॉल करने का एक उदाहरण है।

C # में एक प्रतिनिधि का उपयोग करना

}class Program { public delegate double MathDelegate(double value1, double value2); public static double Add(double value1, double value2) { return value1 + value2; } public static double Subtract(double value1, double value2) { return value1 - value2; } Console.ReadLine(); public static void Main() { MathDelegate mathDelegate = Add; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = Subtract; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 } 

जैसा कि आप देख सकते हैं, हम उस कंपाइलर को बताने के लिए डेलिगेट कीवर्ड का उपयोग करते हैं जो हम एक डेलिगेट टाइप बना रहे हैं।

एक नए प्रतिनिधि प्रकार के स्वत: निर्माण के साथ-साथ प्रतिनिधियों को त्वरित करना आसान है।

आप प्रतिनिधि बनाने के लिए नए कीवर्ड का उपयोग भी कर सकते हैं।

MathDelegate mathDelegate = new MathDelegate(Add) ;

एक त्वरित प्रतिनिधि एक वस्तु है; आप इसका उपयोग भी कर सकते हैं और अन्य तरीकों के तर्क के रूप में पारित कर सकते हैं।

मल्टिकास्ट डेलिगेट्स C # में

प्रतिनिधियों की एक और बड़ी विशेषता यह है कि आप उन्हें एक साथ जोड़ सकते हैं। इसे मल्टीकास्टिंग कहा जाता है। मौजूदा प्रतिनिधि उदाहरण की कॉल सूची में एक और विधि जोड़ने के लिए आप + या + = ऑपरेटर का उपयोग कर सकते हैं। इसी तरह, आप डीटेल असाइनमेंट ऑपरेटर (- या - =) का उपयोग करके कॉल सूची से एक विधि भी निकाल सकते हैं। यह सुविधा C # में घटनाओं के आधार के रूप में कार्य करती है। निम्नलिखित एक मल्टीकास्ट प्रतिनिधि का एक उदाहरण है।

 class Program { static void Hello(string s) { Console.WriteLine(" Hello, {0}!", s); } static void Goodbye(string s) { Console.WriteLine(" Goodbye, {0}!", s); } delegate void Del(string s); static void Main() { Del a, b, c, d; //   a    Hello: a = Hello; //   b    Goodbye: b = Goodbye; //    a  b - c: c = a + b; //  a    c,   d,       Goodbye: d = c - a; Console.WriteLine("Invoking delegate a:"); a("A"); Console.WriteLine("Invoking delegate b:"); b("B"); Console.WriteLine("Invoking delegate c:"); c("C"); Console.WriteLine("Invoking delegate d:"); d("D"); /* : Invoking delegate a: Hello, A! Invoking delegate b: Goodbye, B! Invoking delegate c: Hello, C! Goodbye, C! Invoking delegate d: Goodbye, D! */ Console.ReadLine(); } } 

यह संभव है क्योंकि प्रतिनिधि System.MulticastDelegate वर्ग से इनहेरिट करते हैं, जो बदले में System.Delegate से विरासत में मिलता है। आप अपने प्रतिनिधियों के लिए इन आधार वर्गों में परिभाषित सदस्यों का उपयोग कर सकते हैं।

उदाहरण के लिए, यह जानने के लिए कि एक मल्टीकास्ट प्रतिनिधि कितने तरीकों से कॉल करेगा, आप निम्नलिखित कोड का उपयोग कर सकते हैं:

 int invocationCount = d.GetInvocationList().GetLength(0); 

C # में Covariance और contravariance

जब आप किसी प्रतिनिधि को एक विधि सौंपते हैं, तो विधि हस्ताक्षर को प्रतिनिधि से बिल्कुल मेल नहीं खाता है। इसे कोवरियनस और कंट्रोवर्सी कहा जाता है। Covariance एक विधि को प्रतिनिधि में परिभाषित एक से अधिक व्युत्पन्न वापसी प्रकार की अनुमति देता है। Contravariance पैरामीटर प्रकार के साथ एक विधि की अनुमति देता है जो प्रतिनिधि में प्रकारों से कम व्युत्पन्न हैं।

डेलिगेट कोविरियन

यहाँ सहभोज का एक उदाहरण है,

 class Program { public delegate TextWriter CovarianceDel(); public static StreamWriter MethodStream() { return null; } public static StringWriter MethodString() { return null; } static void Main() { CovarianceDel del; del = MethodStream; del = MethodString; Console.ReadLine(); } } 

चूंकि StreamWriter और StringWriter दोनों TextWriter से विरासत में मिले हैं, आप CovarianceDel उपयोग दोनों विधियों के साथ कर सकते हैं।

प्रतिनिधियों में विरोधाभासी

निम्नलिखित कंट्रोवर्सी का एक उदाहरण है।

 class Program { public static void DoSomething(TextWriter textWriter) { } public delegate void ContravarianceDel(StreamWriter streamWriter); static void Main() { ContravarianceDel del = DoSomething; Console.ReadLine(); } } 

चूंकि DoSomething विधि TextWriter साथ काम कर सकती है, यह निश्चित रूप से StreamWriter साथ काम कर सकती है। विरोधाभासी होने के कारण, आप एक प्रतिनिधि को कॉल कर सकते हैं और StreamWriter का एक उदाहरण DoSomething विधि से पारित कर सकते हैं।

आप यहां इस अवधारणा के बारे में अधिक जान सकते हैं।

C # में लैम्बडा के भाव

कभी-कभी एक संपूर्ण विधि हस्ताक्षर को स्वयं विधि के शरीर से अधिक कोड की आवश्यकता हो सकती है। ऐसी परिस्थितियां भी हैं जिनमें आपको एक प्रतिनिधि के रूप में उपयोग करने के लिए पूरी विधि बनाने की आवश्यकता है।

इन मामलों के लिए, Microsoft ने C # में कुछ नई सुविधाएँ जोड़ी हैं, जैसे कि 2.0 में अनाम विधियाँ। C # 3.0 में, लैम्बडा के भावों को जोड़ने पर चीजें और भी बेहतर हो गईं। नया कोड लिखते समय लैम्ब्डा अभिव्यक्ति का पसंदीदा तरीका है।

निम्नलिखित नवीनतम लैम्ब्डा सिंटैक्स का एक उदाहरण है।

 class Program { public delegate double MathDelegate(double value1, double value2); public static void Main() { MathDelegate mathDelegate = (x,y) => x + y; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = (x, y) => x - y; ; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 Console.ReadLine(); } } 

इस कोड को पढ़ने के लिए, आपको विशेष लंबोदर सिंटैक्स के संदर्भ में "अनुसरण" शब्द का उपयोग करने की आवश्यकता है। उदाहरण के लिए, उपरोक्त उदाहरण में पहला लैम्ब्डा अभिव्यक्ति "एक्स और वाई एक्स और वाई के अलावा का पालन करता है" पढ़ता है।

एक मेम्बा फ़ंक्शन का एक विशिष्ट नाम नहीं है, एक विधि के विपरीत। इस वजह से, लंबदा को गुमनाम कार्य कहा जाता है। आपको वापसी मूल्य के प्रकार को स्पष्ट रूप से निर्दिष्ट करने की आवश्यकता नहीं है। संकलक इसे आपके लंबोदर से स्वचालित रूप से मानता है। और उपरोक्त उदाहरण के मामले में, पैरामीटर प्रकार x और y भी स्पष्ट रूप से निर्दिष्ट नहीं हैं।

आप कई ऑपरेटरों को फैलाते हुए लैम्ब्डा बना सकते हैं। आप लैंबडा बनाने वाले बयानों के चारों ओर घुंघराले ब्रेसिज़ जोड़कर ऐसा कर सकते हैं, जैसा कि नीचे दिए गए उदाहरण में दिखाया गया है।

 MathDelegate mathDelegate = (x,y) => { Console.WriteLine("Add"); return x + y; }; 

कभी-कभी किसी घटना के लिए एक प्रतिनिधि की घोषणा थोड़ी बोझिल लगती है। इस वजह से, .NET फ्रेमवर्क में कई बिल्ट-इन डेलिगेट प्रकार हैं, जिन्हें आप डेलिगेट्स की घोषणा करते समय उपयोग कर सकते हैं। MathDelegate उदाहरण में, आपने निम्नलिखित प्रतिनिधि का उपयोग किया:

 public delegate double MathDelegate(double value1, double value2); 

आप इस प्रतिनिधि को बिल्ट-इन प्रकारों में से एक से बदल सकते हैं, जिसका नाम है Func <int, int, int> ।

उस तरह

 class Program { public static void Main() { Func<int, int, int> mathDelegate = (x,y) => { Console.WriteLine("Add"); return x + y; }; var result = mathDelegate(5, 2); Console.WriteLine(result); // : 7 mathDelegate = (x, y) => x - y; ; result = mathDelegate(5, 2); Console.WriteLine(result); // : 3 Console.ReadLine(); } } 

फंक <...> प्रकार सिस्टम नेमस्पेस में पाए जा सकते हैं। वे प्रतिनिधियों का प्रतिनिधित्व करते हैं जो एक प्रकार का रिटर्न देते हैं और 0 से 16 मापदंडों तक ले जाते हैं। ये सभी प्रकार System.MulticaseDelegate से विरासत में मिले हैं ताकि आप कॉल सूची में कई तरीके जोड़ सकें।

यदि आपको एक प्रतिनिधि प्रकार की आवश्यकता होती है जो मान वापस नहीं करता है, तो आप System.Action प्रकारों का उपयोग कर सकते हैं। वे 0 से 16 मापदंडों तक भी ले जा सकते हैं, लेकिन एक मूल्य वापस नहीं करते हैं।

यहां एक्शन टाइप का उपयोग करने का एक उदाहरण है,

 class Program { public static void Main() { Action<int, int> mathDelegate = (x,y) => { Console.WriteLine(x + y); }; mathDelegate(5, 2); // : 7 mathDelegate = (x, y) => Console.WriteLine(x - y) ; mathDelegate(5, 2); // : 3 Console.ReadLine(); } } 

आप .NET अंतर्निहित प्रतिनिधियों के बारे में अधिक जान सकते हैं।

चीजें तब जटिल हो जाती हैं जब आपका लैम्ब्डा फ़ंक्शन लैम्ब्डा अभिव्यक्ति के बाहर घोषित चर को संदर्भित करने के लिए या इसके लिए शुरू होता है। आमतौर पर, जब कोई नियंत्रण किसी चर के दायरे को छोड़ देता है, तो चर अमान्य हो जाता है। लेकिन क्या होगा अगर प्रतिनिधि स्थानीय चर को संदर्भित करता है। इसे ठीक करने के लिए, संकलक कोड उत्पन्न करता है जो कैप्चर किए गए चर के जीवन का विस्तार करता है, कम से कम जब तक सबसे लंबे समय तक रहने वाले प्रतिनिधि जीवन जीता है। इसे क्लोजर कहा जाता है।

आप यहां क्लोजर के बारे में अधिक जान सकते हैं।

C # में कार्यक्रम

एक लोकप्रिय विकास पैटर्न पर विचार करें - प्रकाशक-ग्राहक (पब / उप)। आप किसी ईवेंट की सदस्यता ले सकते हैं, और तब आपको सूचित किया जाएगा जब ईवेंट प्रकाशक एक नया ईवेंट आरंभ करता है। इस प्रणाली का उपयोग किसी अनुप्रयोग में घटकों के बीच कमजोर संचार स्थापित करने के लिए किया जाता है।

प्रतिनिधि # C में इवेंट सिस्टम के लिए आधार बनाता है।

ईवेंट एक विशेष प्रकार का प्रतिनिधि होता है जो ईवेंट-ओरिएंटेड प्रोग्रामिंग की सुविधा देता है। इवेंट एक वर्ग के सदस्य हैं जिन्हें एक्सेस स्पेसियर की परवाह किए बिना क्लास के बाहर नहीं बुलाया जा सकता है। इसलिए, उदाहरण के लिए, एक घटना को सार्वजनिक घोषित करने से अन्य वर्गों को इस घटना के लिए + = और - = का उपयोग करने की अनुमति मिलेगी, लेकिन एक घटना को ट्रिगर करना (यानी, एक प्रतिनिधि को कॉल करना) केवल उस वर्ग में अनुमति दी जाती है जिसमें घटना होती है। आइए एक उदाहरण देखें,

 // -  Pub public class Pub { // OnChange    callback-  public event Action OnChange = delegate { }; public void Raise() { // OnChange OnChange(); } } 

फिर, किसी अन्य वर्ग में एक विधि घटना के प्रतिनिधि को अपने तरीकों में से एक जोड़कर घटना की सदस्यता ले सकती है:

निम्नलिखित एक उदाहरण है जो दिखा रहा है कि कैसे एक वर्ग एक खुला प्रतिनिधि प्रदान कर सकता है और एक घटना उत्पन्न कर सकता है।

 class Program { static void Main(string[] args) { //   pub Pub p = new Pub(); //  Subscriber 1   OnChange p.OnChange += () => Console.WriteLine("Subscriber 1!"); //  Subscriber 2   OnChange p.OnChange += () => Console.WriteLine("Subscriber 2!"); //  p.Raise(); //   Raise()   callback-     Console.WriteLine("Press enter to terminate!"); Console.ReadLine(); } } 

यहां तक ​​कि अगर घटना को public घोषित किया जाता है, तो इसे उस वर्ग को छोड़कर कहीं भी सीधे ट्रिगर नहीं किया जा सकता है, जहां यह स्थित है।

event कीवर्ड का उपयोग करके, कंपाइलर हमारे क्षेत्र को अवांछित पहुंच से बचाता है।

और भी

यह = (प्रत्यक्ष प्रतिनिधि असाइनमेंट) के उपयोग की अनुमति नहीं देता है। इसलिए, अब आपका कोड + = के बजाय = का उपयोग करके पिछले ग्राहकों को हटाने के जोखिम से सुरक्षित है।

इसके अलावा, आप एक खाली प्रतिनिधि के लिए विशेष OnChange फ़ील्ड इनिशियलाइज़ेशन सिंटैक्स को देख सकते हैं, जैसे delegate { } । यह सुनिश्चित करता है कि हमारा OnChange क्षेत्र कभी भी अशक्त न हो। इसलिए, हम घटना को लागू करने से पहले अशक्त जांच को हटा सकते हैं यदि कोई अन्य वर्ग सदस्य इसे अशक्त नहीं कर रहे हैं।

जब आप उपरोक्त कार्यक्रम चलाते हैं, तो आपका कोड पब का एक नया उदाहरण बनाता है, दो अलग-अलग तरीकों से इस घटना की सदस्यता लेता है, और p.Raise कॉल करके एक घटना उत्पन्न करता है। पब वर्ग किसी भी ग्राहक से पूरी तरह से अनजान है। यह सिर्फ एक घटना उत्पन्न करता है।

इस अवधारणा की गहन समझ के लिए आप मेरा लेख, C # प्रकाशक-सब्सक्राइबर डिज़ाइन पैटर्न भी पढ़ सकते हैं।

खैर, यह सब अभी के लिए है। मुझे उम्मीद है कि आपको यह विचार मिलेगा। पोस्ट पढ़ने के लिए धन्यवाद। कृपया मुझे बताएं कि क्या कोई त्रुटि है या नीचे टिप्पणी में परिवर्तन की आवश्यकता है। अग्रिम धन्यवाद!

उपयोगी लिंक

www.c-sharpcorner.com/blogs/c-sharp-generic-delegates-func-action-and-predicate
docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/covariance-contravariance
https://web.archive.org/web/20150707082707/http://diditwith.net/PermaLink,guid,235646ae-3476-4893-899d-105e4d48c25b.aspx