🏜️ 🌽 👘 .NET में प्रतिनिधि और ईवेंट 👨🏽‍🚒 🤹🏽 👩‍👧‍👧

अनुवादक से। अपने अनुभव से, साथ ही साथ अपने साथी प्रोग्रामर के अनुभव से, मैं कह सकता हूँ कि C # भाषा के सभी बुनियादी कार्यों और .NET प्लेटफ़ॉर्म के बीच, डेलिगेट्स और ईवेंट सबसे जटिल हैं। शायद यह इस तथ्य के कारण है कि पहली नज़र में प्रतिनिधियों और घटनाओं की आवश्यकता अस्पष्ट लगती है, या शब्दों में कुछ भ्रम की वजह से। इसलिए मैंने जॉन स्कीट के प्रतिनिधियों और घटनाओं के बारे में सबसे बुनियादी स्तर पर "उंगलियों पर" एक लेख का अनुवाद करने का फैसला किया। यह उन लोगों के लिए आदर्श है जो C # /.NET से परिचित हैं , लेकिन प्रतिनिधियों और घटनाओं को समझने में कठिनाई होती है।

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

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

प्रतिनिधि प्रकार

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

प्रतिनिधि प्रकार को delegate कीवर्ड का उपयोग करके घोषित किया जाता है। प्रतिनिधि प्रकार स्वतंत्र संस्थाओं के रूप में मौजूद हो सकते हैं, या कक्षाओं या संरचनाओं के अंदर घोषित किए जा सकते हैं। उदाहरण के लिए:

 namespace DelegateArticle { public delegate string FirstDelegate (int x); public class Sample { public delegate void SecondDelegate (char a, char b); } }

इस उदाहरण में, दो प्रकार के प्रतिनिधि घोषित किए जाते हैं। पहला है DelegateArticle.FirstDelegate , जो नेमस्पेस स्तर पर घोषित किया गया है। यह किसी भी विधि के साथ "संगत" है जिसमें टाइप का एक पैरामीटर है int और प्रकार string का मान लौटाता है। दूसरा है DelegateArticle.Sample.SecondDelegate , जो पहले से ही वर्ग के अंदर घोषित है और इसका सदस्य है। यह किसी भी विधि के साथ "संगत" है जिसमें टाइप char दो पैरामीटर हैं और कुछ भी वापस नहीं करता है, क्योंकि रिटर्न प्रकार को void के रूप में चिह्नित किया गया void ।

ध्यान दें कि दोनों प्रकार के प्रतिनिधि के पास एक public पहुंच public । सामान्य तौर पर, संशोधक तक पहुँचने के संबंध में, प्रतिनिधि प्रकार कक्षाओं और संरचनाओं के समान व्यवहार करते हैं। यदि पहुँच संशोधक को प्रतिनिधि प्रकार के लिए स्पष्ट रूप से निर्दिष्ट नहीं किया गया है और इस प्रकार को नामस्थान के अंदर घोषित किया गया है, तो यह उन सभी वस्तुओं के लिए उपलब्ध होगा जो इस नाम स्थान के अंदर भी हैं। यदि एक संशोधक के बिना एक प्रतिनिधि प्रकार को एक वर्ग या संरचना के अंदर घोषित किया जाता है, तो यह बंद हो जाएगा, private संशोधक की कार्रवाई के समान।

प्रतिनिधि प्रकार की घोषणा करते समय, आप static संशोधक का उपयोग नहीं कर सकते हैं।

लेकिन याद रखें कि delegate कीवर्ड का अर्थ हमेशा प्रतिनिधि प्रकार की घोषणा नहीं है। अनाम विधियों का उपयोग करके प्रतिनिधि उदाहरण बनाते समय उसी कीवर्ड का उपयोग किया जाता है।

इस उदाहरण में घोषित दोनों प्रकार के प्रतिनिधियों को System.MulticastDelegate से विरासत में मिला है, जो कि System.Delegate से विरासत में मिला है। व्यवहार में, MulticastDelegate से केवल विरासत पर विचार करें - Delegate और MulticastDelegate बीच का अंतर मुख्य रूप से ऐतिहासिक पहलू में है। ये अंतर .NET 1.0 के बीटा संस्करणों में महत्वपूर्ण थे, लेकिन यह असुविधाजनक था, और Microsoft ने दो प्रकारों को एक में संयोजित करने का निर्णय लिया। दुर्भाग्य से, निर्णय बहुत देर से किया गया था, और जब इसे बनाया गया था, तो उन्होंने .NET की नींव को प्रभावित करने वाले इस तरह के गंभीर बदलाव की हिम्मत नहीं की। इसलिए, Delegate और MulticastDelegate को एक और एक ही MulticastDelegate ।

प्रत्येक प्रकार का प्रतिनिधि जिसे आप MulticastDelegate से विरासत में सदस्य बनाते हैं, अर्थात्: Object और IntPtr मापदंडों के साथ एक निर्माता, साथ ही तीन विधियां: Invoke , BeginInvoke और EndInvoke । हम थोड़ी देर बाद डिजाइनर के पास लौट आएंगे। वास्तव में, ये तीन विधियां वस्तुतः विरासत में नहीं मिली हैं, क्योंकि प्रत्येक प्रकार के प्रतिनिधि के लिए उनके हस्ताक्षर अलग-अलग हैं - यह घोषित प्रतिनिधि प्रकार में विधि के हस्ताक्षर के लिए "अनुकूल" है। उपरोक्त कोड उदाहरण को देखते हुए, हम FirstDelegate प्रतिनिधि के पहले प्रकार के लिए "विरासत में मिली" विधियों को प्राप्त करते हैं:

 public string Invoke (int x); public System.IAsyncResult BeginInvoke(int x, System.AsyncCallback callback, object state); public string EndInvoke(IAsyncResult result);

जैसा कि आप देख सकते हैं, Invoke और EndInvoke का रिटर्न प्रकार प्रतिनिधि के हस्ताक्षर में निर्दिष्ट एक से मेल खाता है, ठीक वैसे ही जैसे Invoke विधि पैरामीटर और पहला BeginInvoke पैरामीटर। हम लेख में बाद में Invoke विधि के उद्देश्य को देखेंगे, और प्रतिनिधियों के उन्नत उपयोग का वर्णन करने वाले अनुभाग में BeginInvoke और EndInvoke । इस बारे में बात करना जल्दबाजी होगी क्योंकि हम यह भी नहीं जानते हैं कि प्रतिनिधि प्रतिनिधि कैसे बनाएं। हम अगले भाग में इस बारे में बात करेंगे।

प्रतिनिधि उदाहरण: मूल बातें

अब हम जानते हैं कि प्रतिनिधि प्रकार की घोषणा कैसे की जाती है और इसमें क्या शामिल है, तो आइए एक नज़र डालते हैं कि प्रतिनिधि का एक उदाहरण कैसे बनाया जाए और इसके साथ क्या किया जा सकता है।

प्रतिनिधि उदाहरण बनाना

सबसे पहले, मैं ध्यान देता हूं कि यह आलेख प्रतिनिधि # उदाहरण बनाने के लिए C # 2.0 और 3.0 की नई विशेषताओं के बारे में बात नहीं करता है, जैसे कि यह सामान्यीकृत प्रतिनिधियों को कवर नहीं करता है जो C # 4.0 में दिखाई दिए थे। क्लोजर, द ब्यूटी ऑफ क्लोजर पर मेरा अलग लेख, नए प्रतिनिधियों के बारे में बात करता है जो C # 2.0 और 3.0 में दिखाई दिए; इसके अलावा, इस विषय पर बहुत सी जानकारी अध्याय 5, 9 और 13 में मेरी पुस्तक " सी # डेथ " में निहित है। मैं सी # 1.0 / 1.1 में दिखाई देने वाली स्पष्ट प्रतिनिधि तत्काल शैली का पालन करूंगा, क्योंकि मेरा मानना है कि इस तरह की शैली को समझना आसान है कि "हुड के नीचे" क्या हो रहा है। अब, जब आप मूल बातें समझते हैं, तो आप C # 2.0, 3.0 और 4.0 से नई सुविधाएँ सीखना शुरू कर सकते हैं; और इसके विपरीत, इस लेख में निर्धारित बुनियादी बातों की दृढ़ समझ के बिना, प्रतिनिधियों की "नई" कार्यक्षमता आपके लिए असहनीय हो सकती है।

जैसा कि पहले उल्लेख किया गया है, प्रतिनिधि के प्रत्येक उदाहरण में आवश्यक रूप से लक्ष्य पद्धति का संदर्भ होता है, जिसे प्रतिनिधि के इस उदाहरण के माध्यम से कहा जा सकता है, और वस्तु (वर्ग या संरचना) के उदाहरण के संदर्भ में जिसमें लक्ष्य विधि घोषित की जाती है। यदि लक्ष्य विधि स्थिर है, तो निश्चित रूप से उदाहरण के लिए कोई संदर्भ नहीं है। सीएलआर प्रतिनिधियों के अन्य, थोड़े अलग रूपों का भी समर्थन करता है, जहां स्टैटिक विधि में दिया गया पहला तर्क डेलीगेट उदाहरण में संग्रहीत किया जाता है, या टारगेट इंस्टेंस विधि के संदर्भ को एक तर्क के रूप में पारित किया जाता है जब विधि को बुलाया जाता है। आप इसके बारे में MSDN पर System.Delegate प्रलेखन में अधिक पढ़ सकते हैं, लेकिन अब, इस स्तर पर, यह अतिरिक्त जानकारी महत्वपूर्ण नहीं है।

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

 /*      d1  d2 .  InstanceMethod   ,    ,       ( ). ,     — this,      . */ FirstDelegate d1 = new FirstDelegate(InstanceMethod); FirstDelegate d2 = new FirstDelegate(this.InstanceMethod); /*  (d3)    ,     ,      ,        . */ FirstDelegate d3 = new FirstDelegate(anotherInstance.InstanceMethod); /*   (d4)      ,  ,     ;        . */ FirstDelegate d4 = new FirstDelegate(instanceOfOtherClass.OtherInstanceMethod); /*    (d5)     ,      ,     ( ). */ FirstDelegate d5 = new FirstDelegate(StaticMethod); /*  (d6)      ,       . */ FirstDelegate d6 = new FirstDelegate(OtherClass.OtherStaticMethod);

जिस प्रतिनिधि निर्माता के बारे में हमने पहले बात की थी, उसके दो पैरामीटर हैं - System.IntPtr नामक एक विधि का संदर्भ। System.IntPtr (MSDN प्रलेखन में इस पैरामीटर को विधि कहा जाता है) और प्रकार के ऑब्जेक्ट के उदाहरण के लिए एक लिंक System.Object (MSDN प्रलेखन में इस पैरामीटर को लक्ष्य कहा जाता है), जो यदि विधि पैरामीटर में निर्दिष्ट विधि स्थिर है, तो अशक्त स्वीकार करता है।

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

प्रतिनिधि उदाहरण प्रस्तुत करना

प्रतिनिधि उदाहरणों को उसी तरह से लागू किया जाता है जैसे कि नियमित तरीके लागू किए जाते हैं। उदाहरण के लिए, प्रतिनिधि उदाहरण d1 को कॉल करना, जिसका प्रकार delegate string FirstDelegate (int x) रूप में बहुत ऊपर से परिभाषित किया गया है, इस प्रकार होगा:

 string result = d1(10);

प्रतिनिधि उदाहरण द्वारा संदर्भित विधि को "भीतर" (या "संदर्भ में", दूसरे शब्दों में) वस्तु उदाहरण, यदि कोई हो, और परिणाम लौटाया जाता है। एक पूर्ण कार्यक्रम लिखना जो प्रतिनिधियों के काम को प्रदर्शित करता है, और एक ही समय में कॉम्पैक्ट, जिसमें "अतिरिक्त" कोड शामिल नहीं है, एक आसान काम नहीं है। हालांकि, नीचे एक समान कार्यक्रम है जिसमें एक स्थिर और एक उदाहरण विधि है। DelegateTest.StaticMethod को कॉल करना StaticMethod को कॉल करने के बराबर है - मैंने उदाहरण को और अधिक समझने के लिए वर्ग का नाम शामिल किया।

 using System; public delegate string FirstDelegate (int x); class DelegateTest { string name; static void Main() { FirstDelegate d1 = new FirstDelegate(DelegateTest.StaticMethod); DelegateTest instance = new DelegateTest(); instance.name = "My instance"; FirstDelegate d2 = new FirstDelegate(instance.InstanceMethod); Console.WriteLine (d1(10)); //    "Static method: 10" Console.WriteLine (d2(5)); //    "My instance: 5" } static string StaticMethod (int i) { return string.Format ("Static method: {0}", i); } string InstanceMethod (int i) { return string.Format ("{0}: {1}", name, i); } }

डेलीगेट इंस्टेंसेस के लिए C # सिंटैक्स, सिंटैक्टिक शुगर है जो इनवोक विधि के इनवोकेशन को मास्क करता है जो प्रत्येक प्रतिनिधि प्रकार के पास होता है। प्रतिनिधि अतुल्यकालिक रूप से चला सकते हैं यदि वे BeginInvoke/EndInvoke प्रदान करते हैं, लेकिन बाद में उस पर अधिक।

डेलीगेट कॉम्बिनेशन

डेलिगेट्स को इस तरह से संयोजित (संयुक्त और घटाया) किया जा सकता है कि जब आप किसी प्रतिनिधि के एक उदाहरण को कॉल करते हैं, तो तरीकों का एक पूरा सेट कहा जाता है, और ये विधियां विभिन्न वर्गों के विभिन्न उदाहरणों से हो सकती हैं। जब मैंने पहले कहा था कि एक प्रतिनिधि उदाहरण एक विधि और एक वस्तु के उदाहरण को संदर्भित करता है, तो मैंने चीजों को थोड़ा सरल किया। यह प्रतिनिधि उदाहरणों के लिए सही है जो समान विधि का प्रतिनिधित्व करते हैं। स्पष्टता के लिए, इसके बाद मैं प्रतिनिधियों के ऐसे उदाहरणों को "साधारण प्रतिनिधि" (सरल प्रतिनिधि) कहूंगा। इसके विपरीत, ऐसे प्रतिनिधि उदाहरण हैं जो वास्तव में सरल प्रतिनिधियों की सूची हैं, जो सभी एक ही प्रकार के प्रतिनिधि पर आधारित हैं (यानी उनके पास संदर्भित तरीकों के समान हस्ताक्षर हैं)। मैं प्रतिनिधियों के ऐसे उदाहरणों को "संयुक्त प्रतिनिधि" (संयुक्त प्रतिनिधि) कहूंगा। कई संयुक्त प्रतिनिधियों को एक दूसरे के साथ जोड़ा जा सकता है, प्रभावी रूप से सरल प्रतिनिधियों की एक बड़ी सूची बन सकती है। संयुक्त प्रतिनिधि में सरल प्रतिनिधियों की सूची को "कॉल सूची" या "मंगलाचरण सूची" कहा जाता है। इस प्रकार, एक कॉल सूची, वस्तुओं के तरीकों और उदाहरणों के लिंक की एक सूची है जो (जोड़े) कॉल के क्रम में स्थित हैं।

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

दो प्रतिनिधि उदाहरणों के बीच संयोजन ("जोड़" भी होता है) आमतौर पर अतिरिक्त ऑपरेटर का उपयोग करके किया जाता है, जैसे कि प्रतिनिधि प्रतिनिधि संख्या या तार थे। इसी तरह, घटाना (शब्द "डिलीट" भी होता है) एक प्रतिनिधि का दूसरे से एक उदाहरण घटाव ऑपरेटर का उपयोग करके किया जाता है। ध्यान रखें कि एक संयुक्त प्रतिनिधि को दूसरे से घटाते समय, घटाव को कॉल सूची के भाग के रूप में किया जाता है। यदि मूल (कम) कॉल सूची में उन सरल प्रतिनिधियों में से एक नहीं है जो कटौती योग्य कॉल सूची में हैं, तो परिणाम (अंतर) मूल सूची होगी। अन्यथा, यदि मूल सूची में सरल प्रतिनिधि हैं, जो कि घटाए गए भाग में भी मौजूद हैं, तो परिणामी सूची में केवल साधारण प्रतिनिधियों की अंतिम घटनाएं अनुपस्थित रहेंगी। हालांकि, शब्दों में वर्णन करने की तुलना में उदाहरणों को दिखाना आसान है। लेकिन अगले स्रोत कोड के बजाय, मैं निम्नलिखित तालिका के उदाहरण का उपयोग करके संयोजन और घटाव के संचालन का प्रदर्शन करूंगा। इसमें, शाब्दिक डी 1, डी 2, डी 3 सरल प्रतिनिधियों को दर्शाते हैं। इसके अलावा, पदनाम [d1, d2, d3] का अर्थ है एक संयुक्त प्रतिनिधि, जिसमें इस क्रम में तीन साधारण शामिल हैं, अर्थात्, जब बुलाया जाता है, तो डी 1 को पहले बुलाया जाएगा, फिर डी 2, और फिर डी 3। खाली कॉल सूची शून्य है।

अभिव्यक्ति	परिणाम
नल + ड १	d1
d1 + अशक्त	d1
डी 1 + डी 2	[डी १, डी २]
d1 + [d2, d3]	[डी १, डी २, डी ३]
[डी १, डी २] + [डी २, डी ३]	[डी १, डी २, डी २, डी ३]
[डी १, डी २] - डी १	d2
[डी १, डी २] - डी २	d1
[डी १, डी २, डी १] - डी १	[डी १, डी २]
[डी १, डी २, डी ३] - [डी १, डी २]	d3
[डी १, डी २, डी ३] - [डी २, डी १]	[डी १, डी २, डी ३]
[डी १, डी २, डी ३, डी १, डी २] - [डी १, डी २]	[डी १, डी २, डी ३]
[डी १, डी २] - [डी १, डी २]	अशक्त

अतिरिक्त संचालक के अलावा, प्रतिनिधि उदाहरणों को स्थिर Delegate.Combine विधि का उपयोग करके जोड़ा जा सकता है; इसी तरह, घटाव ऑपरेशन में स्थिर विधि Delegate.Remove के रूप में एक विकल्प है। सामान्यतया, जोड़ और घटाव संचालक एक प्रकार की संश्लिष्ट शर्करा होती है, और C # संकलक, उन्हें कोड में मिलते हुए, इसे कॉम्बिनेशन और रिमूव मेथड्स में कॉल के साथ बदल देता है। और ठीक है क्योंकि ये विधियां स्थिर हैं, वे आसानी से अशक्त प्रतिनिधियों को संभाल सकते हैं।

जोड़ और घटाव ऑपरेटर हमेशा असाइनमेंट ऑपरेशन d1 += d2 हिस्से के रूप में काम करते हैं, जो पूरी तरह से अभिव्यक्ति d1 = d1+d2 बराबर है; घटाव के लिए भी यही है। फिर से, मैं आपको याद दिलाता हूं कि अतिरिक्त और घटाव में शामिल प्रतिनिधियों के उदाहरण ऑपरेशन के दौरान नहीं बदलते हैं; इस उदाहरण में, चर d1 बस "पुराने" d1 और d2 से मिलकर नए बनाए गए संयुक्त प्रतिनिधि के लिंक को बदल देगा।

कृपया ध्यान दें कि प्रतिनिधियों का जोड़ और हटाना सूची के अंत से होता है, इसलिए कॉल का क्रम x + = y; x - = y; एक खाली ऑपरेशन के बराबर (वेरिएबल x में सब्सक्राइबर की एक सूची होगी, लगभग। अनुवाद। )।

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

यदि एक संयुक्त प्रतिनिधि होता है (जिसमें कई सरल प्रतिनिधियों से युक्त कॉल सूची होती है), और जब इसे कुछ सरल प्रतिनिधि में कहा जाता है, तो एक अपवाद होता है, तो इस बिंदु पर संयुक्त प्रतिनिधि का फोन बंद हो जाएगा, अपवाद फेंक दिया जाएगा, और कॉल सूची से अन्य सभी सरल प्रतिनिधि कभी नहीं बुलाया जाएगा।

घटनाओं

पहली चीजें पहली: घटनाएं प्रतिनिधि उदाहरण नहीं हैं। और अब फिर से:
घटनाएँ प्रतिनिधि उदाहरण नहीं हैं।

एक अर्थ में, यह दुर्भाग्यपूर्ण है कि C # भाषा कुछ स्थितियों में घटनाओं और प्रतिनिधि उदाहरणों के उपयोग की अनुमति देती है, लेकिन अंतर को समझना बहुत महत्वपूर्ण है।

मैं इस नतीजे पर पहुंचा कि घटनाओं को समझने का सबसे अच्छा तरीका उन्हें "जैसे" गुणों के रूप में सोचना है। प्रॉपर्टीज, हालांकि वे "तरह की तरह" फ़ील्ड देखते हैं, वास्तव में निश्चित रूप से नहीं हैं - आप ऐसे गुण बना सकते हैं जो फ़ील्ड्स का उपयोग नहीं करते हैं। घटनाक्रम समान तरीके से व्यवहार करते हैं - हालांकि वे जोड़-घटाव संचालन के मामले में प्रतिनिधि उदाहरणों की तरह दिखते हैं, वे वास्तव में नहीं हैं।

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

जोड़ने और हटाने के तरीकों को C # में इस तरह से eventName += delegateInstance;और कहा जाता है eventName -= delegateInstance;, जहां यह eventNameएक वस्तु के उदाहरण के लिए (उदाहरण के लिए myForm.Click) या एक प्रकार के नाम से उदाहरण के लिए इंगित किया जा सकता है (उदाहरण के लिए, MyClass.SomeEvent)। हालांकि, स्थिर घटनाएं काफी दुर्लभ हैं।

घटनाओं को स्वयं दो तरीकों से घोषित किया जा सकता है। पहला तरीका ऐड और रिमूव तरीकों का स्पष्ट कार्यान्वयन है; यह विधि बहुत ही स्पष्ट रूप से घोषित गेटर्स और इवेंट कीवर्ड के साथ (लेकिन) गुणों के समान है। निम्नलिखित एक प्रतिनिधि प्रकार के लिए एक उदाहरण संपत्ति हैSystem.EventHandler। ध्यान दें कि ऐड और रिमूव मेथड्स में, डेलीगेट इंस्टेंसेस के साथ कोई ऑपरेशन नहीं होता है जो वहां से गुजरता है - मेथड्स मेसेज को कंसोल में प्रिंट करते हैं जिसे वे कहते थे। यदि आप इस कोड को निष्पादित करते हैं, तो आप देखेंगे कि हटाने की विधि को बुलाया जाएगा, इस तथ्य के बावजूद कि हमने इसे हटाने के लिए इसे पास कर दिया था।

 using System; class Test { public event EventHandler MyEvent //  MyEvent   EventHandler { add { Console.WriteLine ("add operation"); } remove { Console.WriteLine ("remove operation"); } } static void Main() { Test t = new Test(); t.MyEvent += new EventHandler (t.DoNothing); t.MyEvent -= null; } //-,        EventHandler void DoNothing (object sender, EventArgs e) { } }

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

क्षेत्र जैसी घटनाएँ

सी # एक प्रतिनिधि चर और एक ही समय में एक घटना घोषित करने का एक आसान तरीका प्रदान करता है। इस पद्धति को एक "फ़ील्ड-जैसी घटना" कहा जाता है और बहुत सरल रूप से घोषित किया जाता है - ठीक उसी तरह जैसे किसी घटना को घोषित करने के लिए "लंबा" रूप (ऊपर दिखाया गया है), लेकिन जोड़ने और हटाने के तरीकों के साथ "शरीर" के बिना।

 public event EventHandler MyEvent;

यह फ़ॉर्म एक प्रतिनिधि चर और उसी प्रकार की एक घटना बनाता है। ईवेंट एक्सेस तक पहुँच मोडिफायर का उपयोग करके ईवेंट घोषणा में निर्धारित किया जाता है (अर्थात, ऊपर के उदाहरण में, एक सार्वजनिक ईवेंट बनाया जाता है), लेकिन प्रतिनिधि चर हमेशा निजी होता है। ईवेंट के निहित निकाय को कंपाइलर द्वारा डेलिगेट वेरिएबल में / से डेलिगेट इंस्टेंसेस को जोड़ने और हटाने के बहुत स्पष्ट संचालन के लिए तैनात किया जाता है, और इन कार्यों को एक लॉक के तहत किया जाता है। C # 1.1 MyEventके लिए, ऊपर दिए गए उदाहरण से घटना निम्न कोड के बराबर है:

 private EventHandler _myEvent; public event EventHandler MyEvent { add { lock (this) { _myEvent += value; } } remove { lock (this) { _myEvent -= value; } } }

यह उदाहरण के सदस्यों के लिए है। स्थैतिक घटनाओं के लिए, चर भी स्थिर है और दृश्य प्रकार पर लॉक कैप्चर किया गया हैtypeof(XXX)जहाँ XXX उस वर्ग का नाम है जिसमें स्थिर घटना घोषित की गई है। C # 2.0 कोई गारंटी नहीं देता है कि ताले को पकड़ने के लिए क्या उपयोग किया जाता है। यह केवल कहता है कि घटनाओं को अवरुद्ध करने के लिए, वर्तमान उदाहरण से जुड़ी एकमात्र वस्तु का उपयोग किया जाता है, और स्थैतिक घटनाओं को अवरुद्ध करने के लिए, वर्तमान वर्ग से जुड़ी एकमात्र वस्तु का उपयोग किया जाता है। (ध्यान दें कि यह केवल कक्षाओं में घोषित घटनाओं के लिए सही है, लेकिन संरचनाओं में नहीं। संरचनाओं में इवेंट लॉकिंग के साथ समस्याएं हैं, और व्यवहार में, मुझे उस संरचना का एक भी उदाहरण याद नहीं है जिसमें घटना घोषित की गई थी।) लेकिन इसमें से कोई भी नहीं है। जितना उपयोगी आप सोच सकते हैं, विवरण के लिए मल्टीथ्रेडिंग अनुभाग देखें ।

तो क्या होता है जब आप देखेंMyEvent? प्रकार के शरीर के अंदर (नेस्टेड प्रकार सहित), संकलक कोड उत्पन्न करता है जो प्रतिनिधि चर का संदर्भ देता है ( _myEventऊपर उदाहरण में)। अन्य सभी संदर्भों में, कंपाइलर कोड उत्पन्न करता है जो घटना को संदर्भित करता है।

क्या कहना है?

अब जब हम प्रतिनिधियों और घटनाओं के बारे में जानते हैं, तो पूरी तरह से तार्किक सवाल उठता है: हमें भाषा में दोनों की आवश्यकता क्यों है? जवाब एनकैप्सुलेशन के कारण है। मान लीजिए कि कुछ काल्पनिक C # /। NET घटनाओं में मौजूद नहीं है। फिर किसी घटना के लिए तृतीय-पक्ष वर्ग कैसे सदस्यता ले सकता है? तीन विकल्प:

सार्वजनिक चर (क्षेत्र) प्रतिनिधि प्रकार के साथ।
एक निजी चर (क्षेत्र) एक प्रतिनिधि के साथ एक सार्वजनिक संपत्ति के रूप में एक आवरण के साथ।
सार्वजनिक चर AddXXXHandler और RemoveXXXHandler के साथ प्रतिनिधि प्रकार के साथ निजी चर (क्षेत्र)।

विकल्प संख्या 1 भयानक है - हम आमतौर पर सार्वजनिक क्षेत्रों से नफरत करते हैं। एक अभिव्यक्ति लिखने के लिए बहुत आसान होती है - संस्करण №2 थोड़ा बेहतर है, लेकिन प्रभावी रूप से ओवरराइड (ओवरराइड) एक एक के लिए ग्राहकों की अनुमति देता है someInstance.MyEvent = eventHandler;, जिसमें सभी मौजूदा प्रोसेसर दिया जाएगा प्रतिस्थापित पर eventHandler, के बजाय जोड़ने मौजूदा करने के लिए eventHandler। साथ ही, आपको अभी भी संपत्ति कोड को स्पष्ट रूप से लिखना होगा।

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

थ्रेड सुरक्षित घटनाओं

(नोट: C # 4 के रिलीज के साथ, यह खंड कुछ पुराना है। अनुवादक से: अधिक जानकारी के लिए, अनुभाग " अनुवादक से देखें ")

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

विडंबना यह है कि दूसरी समस्या पहली के ठीक विपरीत है - इस तथ्य के कारण कि सी # 2.0 में आप गारंटी नहीं दे सकते कि किस लॉक का उपयोग किया जाएगा, आप स्वयं इसका उपयोग नहीं कर सकते हैं जब आप किसी घटना को ट्रिगर करते हैं ताकि आप नवीनतम देख सकें ( इस धारा में वास्तविक) मान। आप किसी और चीज़ पर लॉक का उपयोग कर सकते हैं या विशेष तरीकों का उपयोग कर सकते हैं जो मेमोरी बाधाओं के साथ काम करते हैं, लेकिन यह सब एक अप्रिय aftertaste ¹ the छोड़ देता है ।

यदि आप चाहते हैं कि आपका कोड वास्तव में सुरक्षित होना चाहिए, ताकि जब आप इस घटना को बढ़ाएं, तो आप हमेशा प्रतिनिधि चर के सबसे प्रासंगिक मूल्य का उपयोग करें, और यह भी कि आप यह सुनिश्चित कर सकते हैं कि जोड़ने / हटाने के संचालन एक दूसरे के साथ हस्तक्षेप नहीं करते हैं, फिर प्राप्त करने के लिए इस तरह के "प्रबलित कंक्रीट" धागे की सुरक्षा के लिए, आपको स्वयं ऑपरेशन जोड़ने / निकालने के शरीर को लिखने की आवश्यकता है। नीचे उदाहरण:

 /// <summary> ///    SomeEventHandler,  «» . /// </summary> SomeEventHandler someEvent; /// <summary> ///       SomeEvent. /// </summary> readonly object someEventLock = new object(); /// <summary> ///   /// </summary> public event SomeEventHandler SomeEvent { add { lock (someEventLock) { someEvent += value; } } remove { lock (someEventLock) { someEvent -= value; } } } /// <summary> ///   SomeEvent /// </summary> protected virtual void OnSomeEvent(EventArgs e) { SomeEventHandler handler; lock (someEventLock) { handler = someEvent; } if (handler != null) { handler (this, e); } }

आप अपने सभी घटनाओं के लिए एक लॉक का उपयोग कर सकते हैं, और यहां तक कि किसी अन्य चीज़ के लिए भी इस लॉक का उपयोग कर सकते हैं - यह पहले से ही विशिष्ट स्थिति पर निर्भर करता है। कृपया ध्यान दें कि आपको लॉक के अंदर एक स्थानीय चर के वर्तमान मूल्य को "लिखने" की आवश्यकता है (सबसे वर्तमान मूल्य प्राप्त करने के लिए), और फिर इस मूल्य को शून्य के लिए जांचें और इसे लॉक के बाहर करें : किसी ईवेंट कॉल के दौरान लॉक को पकड़ना एक बहुत बुरा विचार है। आसानी से गतिरोध। यह समझाने के लिए, कल्पना करें कि एक इवेंट हैंडलर को किसी अन्य कार्य को करने के लिए दूसरे थ्रेड का इंतजार करना चाहिए, और यदि यह अन्य थ्रेड आपके ईवेंट के लिए ऐड / रिमूवल ऑपरेशन को कॉल करता है, तो आपको एक डेडलॉक मिलेगा।

उपरोक्त कोड सही तरीके से काम करता है क्योंकि एक बार जब स्थानीय चर को handlerकिसी तरह से सेट किया जाता है, तो हैंडलर का मूल्य बदल नहीं जाएगा भले ही वह खुद ही बदल जाए someEvent। यदि सभी ईवेंट हैंडलर ईवेंट से अनसब्सक्राइब हो जाते हैं, तो कॉल लिस्ट खाली हो जाएगी, यह someEventअशक्त हो जाएगा, लेकिन यह handlerअपना मान रखेगा, जो असाइनमेंट के समय था। वास्तव में, प्रतिनिधि उदाहरण अपरिवर्तनीय हैं, इसलिए जो भी ग्राहक एक असाइनमेंट ( handler = someEvent) और एक ईवेंट ( handler (this, e);) कॉल के बीच साइन अप करेंगे, उन्हें नजरअंदाज कर दिया जाएगा।

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

 /// <summary> ///    SomeEventHandler,  «» . /// </summary> SomeEventHandler someEvent; /// <summary> ///   /// </summary> public event SomeEventHandler SomeEvent { add { someEvent += value; } remove { someEvent -= value; } } /// <summary> ///   SomeEvent /// </summary> protected virtual void OnSomeEvent(EventArgs e) { if (someEvent != null) { someEvent (this, e); } }

यदि, विधि कॉल के समय, OnSomeEventप्रतिनिधि चर someEventमें प्रतिनिधि उदाहरणों की सूची नहीं होती है (इस तथ्य के कारण कि उन्हें ऐड पद्धति के माध्यम से नहीं जोड़ा गया था या हटाए गए विधि के माध्यम से हटा दिया गया था), तो इस चर का मान सुस्त हो जाएगा, और इस तरह के मूल्य के साथ इसके आह्वान से बचने के लिए, एक अशक्त जाँच जोड़ी गई है। इसी तरह की स्थिति को दूसरे तरीके से हल किया जा सकता है। आप एक नो-ऑप प्रतिनिधि का एक उदाहरण बना सकते हैं जो डिफ़ॉल्ट चर के लिए बाध्य होगा और हटाया नहीं जाएगा। इस मामले में, विधि में OnSomeEventआपको प्रतिनिधि प्रतिनिधि के मूल्य को प्राप्त करने और कॉल करने की आवश्यकता है। यदि "वास्तविक" प्रतिनिधि उदाहरणों को नहीं जोड़ा गया है, तो एक स्टब बस कहा जाएगा।

प्रतिनिधि उदाहरण: अन्य तरीके

इससे पहले लेख में, मैंने दिखाया कि एक कॉल के someDelegate(10)लिए सिर्फ एक शॉर्टहैंड है someDelegate.Invoke(10)। इसके अलावा Invoke, प्रतिनिधि प्रकार भी BeginInvoke/ जोड़ी की विधियों के माध्यम से अतुल्यकालिक व्यवहार रखते हैं EndInvoke। सीएलआई में, वे वैकल्पिक हैं, लेकिन सी # में वे हमेशा से हैं। वे .NET के बाकी हिस्सों के समान ही अतुल्यकालिक निष्पादन मॉडल का पालन करते हैं, जिससे आप कॉलबैक हैंडलर को एक ऑब्जेक्ट के साथ निर्दिष्ट कर सकते हैं जो राज्य की जानकारी संग्रहीत करता है। एक अतुल्यकालिक कॉल के परिणामस्वरूप, सिस्टम द्वारा निर्मित थ्रेड्स में कोड निष्पादित होता है और थ्रेड पूल पूल (.NET) में स्थित होता है।

पहले उदाहरण में, ^{2 2 से} नीचे प्रस्तुत , कोई कॉलबैक नहीं हैं, वे बस उपयोग करते हैं BeginInvokeऔरEndInvokeएक धागे में। इस तरह का कोड टेम्प्लेट कभी-कभी उपयोगी होता है जब एक धागे का उपयोग सामान्य रूप से सिंक्रोनस के संचालन के लिए किया जाता है, लेकिन साथ ही इसमें ऐसे तत्व शामिल होते हैं जिन्हें समानांतर में निष्पादित किया जा सकता है। कोड की सादगी के लिए, उदाहरण में सभी विधियां स्थिर हैं, लेकिन निश्चित रूप से आप "एसिंक्रोनस" प्रतिनिधियों का उपयोग उदाहरण के तरीकों के साथ कर सकते हैं, और व्यवहार में यह और भी अधिक बार होगा। विधि EndInvokeप्रतिनिधि मान को इनवॉइस करने के परिणामस्वरूप लौटाया गया मान देता है। यदि प्रतिनिधि अपवाद के आह्वान के दौरान कोई अपवाद होता है, तो वह अपवाद फेंक देगा और EndInvoke।

 using System; using System.Threading; delegate int SampleDelegate(string data); class AsyncDelegateExample1 { static void Main() { SampleDelegate counter = new SampleDelegate(CountCharacters); SampleDelegate parser = new SampleDelegate(Parse); IAsyncResult counterResult = counter.BeginInvoke("hello", null, null); IAsyncResult parserResult = parser.BeginInvoke("10", null, null); Console.WriteLine("   ID = {0}  ", Thread.CurrentThread.ManagedThreadId); Console.WriteLine("  '{0}'", counter.EndInvoke(counterResult)); Console.WriteLine("  '{0}'", parser.EndInvoke(parserResult)); Console.WriteLine("   ID = {0} ", Thread.CurrentThread.ManagedThreadId); } static int CountCharacters(string text) { Thread.Sleep(2000); Console.WriteLine("    '{0}'    ID = {1}", text, Thread.CurrentThread.ManagedThreadId); return text.Length; } static int Parse(string text) { Thread.Sleep(100); Console.WriteLine("  '{0}'    ID = {1}", text, Thread.CurrentThread.ManagedThreadId); return int.Parse(text); } }

विधि कॉल Thread.Sleepकेवल आदेश प्रदर्शित करने के लिए है कि तरीकों में डाला जाता है CountCharactersऔर Parseवास्तव में मुख्य प्रवाह के साथ समानांतर में किया जाता है। CountCharacters2-सेकंड की नींद थ्रेड पूल को अन्य थ्रेड्स में कार्य करने के लिए मजबूर करने के लिए पर्याप्त है - थ्रेड पूल उन अनुरोधों को क्रमबद्ध करता है जिन्हें पूरा करने में बहुत समय नहीं लगता है, इस प्रकार नए थ्रेड्स के अत्यधिक निर्माण से बचना (नए थ्रेड्स बनाना एक अपेक्षाकृत संसाधन-गहन ऑपरेशन है) । लंबे समय तक प्रवाह को "सुस्त" करके, हम इस प्रकार एक "भारी", समय लेने वाले कार्य का अनुकरण करते हैं। और यहाँ हमारे कार्यक्रम का निष्कर्ष है:

	आईडी = 9 के साथ मुख्य धागा जारी है
	आईडी = 10 के साथ धारा में '10' पार्सिंग स्ट्रिंग
	आईडी = 6 के साथ एक स्ट्रीम में स्ट्रिंग 'हैलो' में वर्णों की गिनती करना
	काउंटर ने '5' लौटाया
	पार्सर ने लौटाया '10'
	आईडी = 9 के साथ मुख्य धागा समाप्त हो गया

यदि थर्ड-पार्टी थ्रेड में प्रतिनिधि निष्पादन प्रक्रिया अभी तक पूरी नहीं हुई है, तो EndInvokeमुख्य थ्रेड में एक विधि कॉल Thread.Joinमैन्युअल रूप से बनाए गए थ्रेड्स के लिए एक कॉल के समान प्रभाव पड़ेगा - मुख्य थ्रेड तृतीय-पक्ष थ्रेड में कार्य पूरा होने तक प्रतीक्षा करेगा। IAsyncResultविधि द्वारा लौटाए गए मान BeginInvokeऔर इनपुट में उत्तीर्ण EndInvokeहोने का उपयोग राज्य BeginInvoke(अंतिम पैरामीटर - Object state) के माध्यम से स्थानांतरित करने के लिए किया जा सकता है , हालांकि, प्रतिनिधियों का उपयोग करते समय ऐसे हस्तांतरण की आवश्यकता अक्सर उत्पन्न नहीं होती है।

ऊपर का कोड बहुत सरल है, लेकिन प्रतिनिधि के पूरा होने के बाद कॉलबैक मॉडल की तुलना में पर्याप्त कुशल नहीं है। एक नियम के रूप में, यह कॉलबैक विधि में है EndInvokeकि विधि को कहा जाता है जो प्रतिनिधि के परिणाम को लौटाता है। हालांकि, विशुद्ध रूप से सैद्धांतिक रूप से, यह कॉल अभी भी मुख्य थ्रेड (जैसा कि ऊपर दिए गए उदाहरण में है) को ब्लॉक करता है, लेकिन व्यवहार में थ्रेड को ब्लॉक नहीं किया जाएगा, क्योंकि कॉलबैक विधि को केवल तभी निष्पादित किया जाता है जब प्रतिनिधि ने अपना कार्य पूरा कर लिया हो। कॉलबैक विधि कुछ अतिरिक्त डेटा के साथ एक राज्य का उपयोग कर सकती है, जिसे विधि से इसे पारित किया जाएगाBeginInvoke। नीचे दिए गए उदाहरण पार्सिंग के लिए समान प्रतिनिधियों का उपयोग करता है और ऊपर उदाहरण में एक पंक्ति में वर्णों की संख्या की गिनती करता है, लेकिन इस बार कॉलबैक पद्धति के साथ जिसमें कंसोल पर परिणाम प्रदर्शित होता है। stateप्रकार पैरामीटर का Objectउपयोग कंसोल के परिणाम को आउटपुट करने के लिए प्रारूप के बारे में जानकारी प्रसारित करने के लिए किया जाता है, और इसके लिए धन्यवाद हम DisplayResultदोनों अतुल्यकालिक प्रतिनिधि कॉल को संभालने के लिए एक कॉलबैक विधि का उपयोग कर सकते हैं । कलाकारों नोट IAsyncResultटाइप करने के लिए AsyncResult: कॉलबैक द्वारा प्राप्त मान हमेशा उदाहरण है AsyncResult, और यह के माध्यम से हम प्रतिनिधि की मूल प्रति, है, जिसके परिणामस्वरूप का उपयोग कर प्राप्त प्राप्त कर सकते हैं EndInvoke। यहां थोड़ा अजीब है कि AsyncResultनाम स्थान में प्रकार घोषित किया गया हैSystem.Runtime.Remoting.Messaging(जिसे आपको कनेक्ट करने की आवश्यकता है), जबकि अन्य सभी प्रकार में Systemया में घोषित किए गए हैं System.Threading।

 using System; using System.Threading; using System.Runtime.Remoting.Messaging; delegate int SampleDelegate(string data); class AsyncDelegateExample2 { static void Main() { SampleDelegate counter = new SampleDelegate(CountCharacters); SampleDelegate parser = new SampleDelegate(Parse); AsyncCallback callback = new AsyncCallback(DisplayResult); counter.BeginInvoke("hello", callback, "  '{0}'    ID = {1}"); parser.BeginInvoke("10", callback, "  '{0}'    ID = {1}"); Console.WriteLine("   ID = {0}  ", Thread.CurrentThread.ManagedThreadId); Thread.Sleep(3000); Console.WriteLine("   ID = {0} ", Thread.CurrentThread.ManagedThreadId); } static void DisplayResult(IAsyncResult result) { string format = (string)result.AsyncState; AsyncResult delegateResult = (AsyncResult)result; SampleDelegate delegateInstance = (SampleDelegate)delegateResult.AsyncDelegate; Int32 methodResult = delegateInstance.EndInvoke(result); Console.WriteLine(format, methodResult, Thread.CurrentThread.ManagedThreadId); } static int CountCharacters(string text) { Thread.Sleep(2000); Console.WriteLine("    '{0}'    ID = {1}", text, Thread.CurrentThread.ManagedThreadId); return text.Length; } static int Parse(string text) { Thread.Sleep(100); Console.WriteLine("  '{0}'    ID = {1}", text, Thread.CurrentThread.ManagedThreadId); return int.Parse(text); } }

इस बार, लगभग सभी काम थ्रेड पूल से धागे में किया जाता है। मुख्य सूत्र केवल अतुल्यकालिक कार्यों की शुरुआत करता है और इन सभी कार्यों के पूरा होने तक "सो जाता है"। थ्रेड पूल से सभी थ्रेड्स बैकग्राउंड थ्रेड होते हैं जो एप्लिकेशन को "होल्ड" नहीं कर सकते हैं (अर्थात, वे इसे बंद करने से नहीं रोक सकते हैं), और ताकि बैकग्राउंड थ्रेड्स में प्रतिनिधियों के काम करने से पहले आवेदन समाप्त न हो, हम कॉल Thread.Sleep(3000)को मुख्य धागे में लागू किया - यह आशा की जाती है कि प्रतिनिधियों को पूरा करने और पूरा करने के लिए 3 सेकंड पर्याप्त हैं। आप लाइन को टिप्पणी करके इसे सत्यापित कर सकते हैं Thread.Sleep(3000)- कार्यक्रम शुरू होने के बाद लगभग तुरंत समाप्त हो जाएगा।

हमारे कार्यक्रम का परिणाम नीचे प्रस्तुत किया गया है। कंसोल पर आउटपुट परिणाम के क्रम पर ध्यान दें - काउंटर के परिणाम से पहले पार्सर का परिणाम दिखाई दिया, क्योंकि पर्यावरण जब आदेश के संरक्षण की गारंटी नहीं देता है EndInvoke। पिछले उदाहरण में, काउंटर (2 सेकंड) की तुलना में पार्सिंग को बहुत तेजी से (100 एमएस) पूरा किया गया था, हालांकि, मुख्य धागा काउंटर के परिणाम को प्रदर्शित करने के लिए दोनों का इंतजार कर रहा था, और उसके बाद ही पार्सर।

	आईडी = 9 के साथ मुख्य धागा जारी है
	आईडी = 11 के साथ धारा में '10' पार्सिंग स्ट्रिंग
	Parser ने ID = 11 के साथ स्ट्रीम में '10' लौटाया
	ID = 10 के साथ एक स्ट्रीम में स्ट्रिंग 'हैलो' में वर्णों की गिनती करना
	काउंटर ने आईडी = 10 के साथ स्ट्रीम में '5' लौटाया
	आईडी = 9 के साथ मुख्य धागा समाप्त हो गया

याद रखें कि इस अतुल्यकालिक मॉडल का उपयोग करते समय आपको कॉल करना होगा EndInvoke; मेमोरी लीक और हैंडलर की अनुपस्थिति की गारंटी देने के लिए यह आवश्यक है। कुछ मामलों में, EndInvokeलीक के अभाव में , यह नहीं हो सकता है, लेकिन किसी को इसके लिए उम्मीद नहीं करनी चाहिए। अधिक विस्तृत जानकारी के लिए, आप मेरे लेख " बहु सूत्रण में .NET: परिचय और सुझाव " का उल्लेख कर सकते हैं , विशेष रूप से, " थ्रेड पूल और अतुल्यकालिक विधियों " अनुभाग के लिए, मल्टीथ्रेडिंग के लिए समर्पित ।

निष्कर्ष

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

नोट

1. नोट ट्रांस।मैं स्वीकार करता हूं कि जॉन स्कीट का स्पष्टीकरण बहुत ही धीमा और उखड़ा हुआ है। विस्तार से समझने के लिए कि वर्तमान उदाहरण और प्रकार पर रोक क्यों खराब है, और एक अलग-अलग रीड-ओनली निजी क्षेत्र में प्रवेश क्यों किया जाना चाहिए, मैं जेफरी रिक्टर द्वारा "सीएलआर के माध्यम से सीएलआर" पुस्तक का उपयोग करने की अत्यधिक अनुशंसा करता हूं, जो पहले से ही 4 संस्करणों से बच गया है। यदि हम 2006 के दूसरे संस्करण के बारे में बात करते हैं, तो 2007 में रूसी में अनुवादित, इस समस्या की जानकारी "भाग 5. सीएलआर टूल्स" - "अध्याय 24. स्ट्रीम सिंक्रनाइज़ेशन" में स्थित है - अनुभाग "क्यों" "महान" विचार इस तरह के असफल होने के लिए निकला। "।

2. नोट ट्रांस।यह और निम्न कोड उदाहरण, साथ ही कंसोल के लिए उनका आउटपुट, जे। स्कीट से मूल उदाहरणों की तुलना में थोड़ा बदल दिया गया है। अनुवाद के अतिरिक्त, मैंने थ्रेड आइडेंटिफ़ायर के आउटपुट को जोड़ा ताकि यह स्पष्ट रूप से दिखाई दे कि किस कोड को किस थ्रेड में निष्पादित किया गया है।

अनुवादक से

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

एलेक्सी डुबोत्सेव। प्रतिनिधि और घटनाएँ (RSDN)।
यद्यपि यह लेख नया नहीं है (2006 को दिनांकित) और केवल प्रतिनिधियों और घटनाओं की मूल बातें मानता है, "मूल बातों पर विचार" का स्तर बहुत गहरा है: यहाँ मल्टीकास्टडेगेट के प्रकार पर करीब से नज़र है, विशेष रूप से संयुक्त प्रतिनिधियों के संदर्भ में, और एमएसआईएल स्तर पर ऑपरेशन के सिद्धांत का वर्णन है, और वर्ग का विवरण है। EventHandlerList, और अधिक। सामान्य तौर पर, यदि आप एक गहरे स्तर पर प्रतिनिधियों और घटनाओं की मूल बातों पर विचार करना चाहते हैं, तो यह लेख निश्चित रूप से आपके लिए है।

coffeecupwinner । विस्तार से नेट की घटनाओं ।
मुझे आशा है कि आपने थ्रेड सेफ इवेंट सेक्शन की शुरुआत में पुरानी सामग्री के बारे में एक नोट देखा होगा।"? सी # 4 में, स्कीट और रिक्टर द्वारा आलोचना की गई फील्ड जैसी घटनाओं के आंतरिक कार्यान्वयन को पूरी तरह से नया रूप दिया गया है: अब थ्रेड सुरक्षा को इंटरलॉक किए गए ।CompareExchange के माध्यम से, बिना किसी ताले के लागू किया जाता है। इसके बारे में, अन्य बातों के अलावा, और इस लेख को बताता है। सामान्य तौर पर, लेख केवल घटनाओं को स्पष्ट रूप से मानता है, लेकिन जॉन स्कीट की तुलना में बहुत गहरे स्तर पर।

डैनियल ग्रुनवल्ड। andreycha । C # में कमजोर ईवेंट ।
जब एक ओर C # /। NET के फायदे के बारे में बात हो रही है और दूसरी तरफ C ++, दूसरी चीजों के बीच लिखने वाला पहला, स्वचालित कचरा संग्रह है, जो मेमोरी लीक को एक त्रुटि वर्ग के रूप में समाप्त करता है। हालांकि, सब कुछ इतना रसपूर्ण नहीं है: घटनाओं से मेमोरी लीक हो सकती है, और यह बहुत विस्तृत लेख इन समस्याओं को हल करने के लिए समर्पित है।

भड़का हुआ । मुझे C # में प्रतिनिधियों की आवश्यकता क्यों है?
जैसा कि मैंने परिचय में उल्लेख किया है, नौसिखिए डेवलपर्स में, प्रतिनिधियों के साथ गलतफहमी उनके उपयोग की आवश्यकता के कारण दिखाई देने वाले कारणों की कमी के कारण है। यह लेख बहुत स्पष्ट रूप से कुछ स्थितियों को प्रदर्शित करता है जहां प्रतिनिधि बेहद उपयुक्त होंगे। इसके अलावा, C # 2nd और 3rd वर्जन में पेश किए गए डेलीगेट्स के नए फीचर्स यहां दिखाए गए हैं।

.NET में प्रतिनिधि और ईवेंट