🚽 🙆🏾 🧚🏾 .NET की घटनाओं को विस्तार से 👽 👨‍⚖️ 👐🏿

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

एक घटना क्या है?

C # में एक घटना एक इकाई है जो दो संभावनाएं प्रदान करती है: एक वर्ग के लिए, परिवर्तनों की रिपोर्ट करने के लिए, और अपने उपयोगकर्ताओं के लिए, उन्हें जवाब देने के लिए।
घटना की घोषणा उदाहरण:

public event EventHandler Changed;

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

घटना कार्यक्षेत्र - प्रतिनिधि

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

 Action a = () => Console.Write("A"); //Action   public delegate void Action(); Action b = a; Action c = a + b; Action d = a - b; a(); // A b(); // A c(); // AA d(); //  NullReferenceException, .. d == null

घटनाएँ - डिफ़ॉल्ट कार्यान्वयन

C # में घटनाओं को दो तरीकों से परिभाषित किया जा सकता है:

किसी घटना का कार्यान्वयन (क्षेत्र जैसी घटना)।
स्पष्ट घटना कार्यान्वयन।

मैं स्पष्ट करूंगा कि इस मामले में "स्पष्ट" और "निहित" शब्द विनिर्देश में परिभाषित नहीं हैं, लेकिन केवल अर्थ के भीतर कार्यान्वयन विधि का वर्णन करते हैं।

सबसे अधिक इस्तेमाल किए जाने वाले घटना कार्यान्वयन पर विचार करें - निहित। मान लें कि आपके पास C # 4 में निम्न स्रोत कोड है (यह महत्वपूर्ण है, पहले के संस्करणों के लिए थोड़ा अलग कोड उत्पन्न होता है, जिसे बाद में वर्णित किया जाएगा):

 class Class { public event EventHandler Changed; }

इन पंक्तियों को संकलक द्वारा निम्नलिखित के समान कोड में अनुवादित किया जाएगा:

 class Class { EventHandler hanged; public event EventHandler Changed { add { EventHandler eventHandler = this.changed; EventHandler comparand; do { comparand = eventHandler; eventHandler = Interlocked.CompareExchange<EventHandler>(ref this.changed, comparand + value, comparand); } while(eventHandler != comparand); } remove { EventHandler eventHandler = this.changed; EventHandler comparand; do { comparand = eventHandler; eventHandler = Interlocked.CompareExchange<EventHandler>(ref this.changed, comparand - value, comparand); } while (eventHandler != comparand); } } }

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

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

ऐड और ऐड के साथ एड करें

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

ईवेंट को कैसे सब्सक्राइब किया जाता है और कहा जाता है?

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

घटना संशोधक

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

किस प्रकार के आयोजन होते हैं?

जैसा कि पहले ही उल्लेख किया गया है, घटना का प्रकार हमेशा प्रतिनिधि का प्रकार होना चाहिए। इवेंट के लिए मानक प्रकार EventHandler और EventHandler <TEventArgs> प्रकार हैं जहां TEventArgs EventArgs का वंशज है। EventHandler प्रकार का उपयोग तब किया जाता है जब घटना तर्क प्रदान नहीं किए जाते हैं, और EventHandler <TEventArgs> प्रकार का उपयोग किया जाता है जब घटना तर्क होते हैं, तो उनके लिए एक अलग वर्ग बनाया जाता है - EventArgs से एक वारिस। आप किसी अन्य प्रकार के प्रतिनिधियों का भी उपयोग कर सकते हैं, लेकिन टाइप किए गए EventHandler <TEventArgs> का उपयोग करना अधिक तार्किक और सुंदर दिखता है।

C # 3 में सब कुछ कैसे है?

ऊपर वर्णित फ़ील्ड-जैसी घटना का कार्यान्वयन C # 4 भाषा (.NET 4.0) से मेल खाता है। पहले के संस्करणों के लिए, बहुत महत्वपूर्ण अंतर हैं।
एक अंतर्निहित कार्यान्वयन लॉकल के साथ थ्रेड सुरक्षा प्रदान करने के लिए लॉक (यह) का उपयोग करता है। स्थिर घटनाओं के लिए, लॉक (टाइपोफ़ (क्लास)) का उपयोग किया जाता है। यहाँ C # 3 में संकलक की अंतर्निहित घटना परिभाषा के समान कोड है:

 class Class { EventHandler changed; public event EventHandler Changed { add { lock(this) { changed = changed + value; } } remove { lock(this) { changed = changed - value; } } } }

इसके अलावा, कक्षा के अंदर घटना के साथ काम एक प्रतिनिधि के रूप में किया जाता है, अर्थात। + = और - = कॉल डेलिगेट। कोम्बाइन और डेलिगेट। सीधे जोड़ें / निकालें विधियों को दरकिनार करें। यह परिवर्तन C # 4 में प्रोजेक्ट बनाना असंभव बना सकता है! C # 3 में, + = और - = का परिणाम एक प्रतिनिधि था, क्योंकि एक चर को असाइन करने का परिणाम हमेशा निर्दिष्ट मूल्य होता है। सी # 4 में, परिणाम शून्य है, क्योंकि जोड़ें / निकालें विधियाँ मान नहीं लौटाते हैं।

भाषा के विभिन्न संस्करणों पर काम में बदलाव के अलावा, कई और विशेषताएं हैं।

फ़ीचर # 1 - सब्सक्राइबर लाइफ एक्सटेंशन

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

फ़ीचर # 2 - स्पष्ट इंटरफ़ेस कार्यान्वयन

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

 EventHandler changed; event EventHandler ISomeInterface.Changed { add { changed += value; } remove { changed -= value; } }

फ़ीचर # 3 - सुरक्षित कॉल

कॉल से पहले की घटनाओं को शून्य के लिए जाँचना चाहिए, जो ऊपर वर्णित प्रतिनिधियों के काम से आता है। इससे कोड बढ़ता है, जिससे बचने के लिए कम से कम दो तरीके हैं। पहली विधि का वर्णन जॉन स्कीट ने अपनी पुस्तक C # में गहराई से किया है :

 public event EventHandler Changed = delegate { };

संक्षिप्त और संक्षिप्त। हम ईवेंट प्रतिनिधि को एक खाली विधि के साथ आरंभ करते हैं, इसलिए यह कभी भी अशक्त नहीं होगा। प्रतिनिधि से इस विधि को घटाना असंभव है, क्योंकि यह प्रतिनिधि के आरंभ के दौरान परिभाषित किया गया है और इसका न तो कोई नाम है और न ही कार्यक्रम में कहीं से इसका कोई लिंक है।

दूसरा तरीका एक विधि लिखना है जिसमें आवश्यक नल की जांच शामिल है। यह तकनीक विशेष रूप से .NET 3.5 और बाद में काम करती है, जहां एक्सटेंशन के तरीके उपलब्ध हैं। चूंकि एक्सटेंशन विधि को कॉल करते समय, जिस ऑब्जेक्ट को कहा जाता है वह इस पद्धति का सिर्फ एक पैरामीटर है, यह ऑब्जेक्ट एक खाली संदर्भ हो सकता है, जिसका उपयोग इस मामले में किया जाता है।

 public static class EventHandlerExtensions { public static void SafeRaise(this EventHandler handler, object sender, EventArgs e) { if(handler != null) handler(sender, e); } public static void SafeRaise<TEventArgs>(this EventHandler<TEventArgs> handler, object sender, TEventArgs e) where TEventArgs : EventArgs { if(handler != null) handler(sender, e); } }

इस प्रकार, हम Changed.SafeRaise (यह, EventArgs.Empty) जैसी घटनाओं को ट्रिगर कर सकते हैं, जो हमें कोड की लाइनें बचाता है। जब हमारे पास EventArgs.Empty हो तो आप मामले के लिए एक्सटेंशन विधि के तीसरे संस्करण को भी परिभाषित कर सकते हैं, ताकि उन्हें स्पष्ट रूप से पारित न किया जा सके। फिर कोड को बदलकर बदल दिया जाएगा। कैफेइसे (यह), लेकिन मैं इस दृष्टिकोण की सिफारिश नहीं करूंगा, क्योंकि आपकी टीम के अन्य सदस्यों के लिए, यह एक खाली तर्क पारित करने के रूप में स्पष्ट नहीं हो सकता है।

सूक्ष्मता संख्या 4 - मानक कार्यान्वयन में क्या गलत है?

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

बोनस: माइक्रोसॉफ्ट की कोशिश गर्भ-निरोधी घटनाओं को बनाने की है

C # 4 के पहले बीटा में, Microsoft ने घटनाओं में विरोधाभासी जोड़ने की कोशिश की। इसने आपको EventHandler <MyEventArgs> ईवेंट के लिए सब्सक्राइब करने की अनुमति दी, जिसमें EventHandler <EventArgs> सिग्नेचर का उपयोग किया गया और इवेंट डेलिगेट में एक अलग (लेकिन उपयुक्त) सिग्नेचर के साथ कई तरीकों को काम किया गया। ऐसा कोड संकलित किया गया, लेकिन एक रनटाइम त्रुटि के साथ क्रैश हो गया। जाहिर है, वे इसके आसपास नहीं पहुंच सके और C # 4 की रिलीज में, EventHandler के लिए विरोधाभासी को अक्षम कर दिया गया।
यदि आप सदस्यता लेते समय किसी प्रतिनिधि के स्पष्ट निर्माण को छोड़ देते हैं, तो यह ध्यान देने योग्य नहीं है, उदाहरण के लिए, निम्नलिखित कोड आपको संकलित करता है:

 public class Tests { public event EventHandler<MyEventArgs> Changed; public void Test() { Changed += ChangedMyEventArgs; Changed += ChangedEventArgs; } void ChangedMyEventArgs(object sender, MyEventArgs e) { } void ChangedEventArgs(object sender, EventArgs e) { } }

ऐसा इसलिए है क्योंकि कंपाइलर ही नए EventHandler <MyEventArgs> (...) को दोनों सब्सक्रिप्शन में स्थानापन्न करेगा। यदि आप कम से कम एक स्थान पर नए EventHandler <EventArgs> (...) का उपयोग करते हैं, तो संकलक त्रुटि की सूचना देगा - EventHandler के प्रकार को परिवर्तित करना असंभव है परियोजना)।

सूत्रों का कहना है

निम्नलिखित स्रोतों की एक सूची है, जिनमें से कुछ का उपयोग लेख की तैयारी में किया गया था। मैं जॉन स्कीट (जॉन स्कीट) की पुस्तक को पढ़ने की सलाह देता हूं, जिसमें न केवल प्रतिनिधियों, बल्कि कई अन्य भाषा टूल का भी विस्तार से वर्णन किया गया है।

.NET की घटनाओं को विस्तार से