C # मानवीय घटनाएँ

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

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


आपको क्या सीखने की आवश्यकता है:

• 1. आपको सीखने से नहीं डरना चाहिए। कृपया धीरे और सोच समझकर पढ़ें।
• 2. आपको कक्षाओं और विधियों को समझना चाहिए।
• 3. आपको यह समझने के लिए पता होना चाहिए कि प्रतिनिधि हैं। यद्यपि, आप लेख पढ़ते समय उन्हें समझने की कोशिश कर सकते हैं।

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

तो, एक घटना , यह एक स्थिति है जब यह होता है, कुछ क्रियाएं होंगी। घटना अपने आप में एक निश्चित संरचना है।

मान लीजिए कार्य है: तीन वर्गों को परिभाषित किया गया है। पहला वर्ग एक लूप का उपयोग करके 100 तक गिना जाएगा। अन्य दो कक्षाएं काउंटर की गणना के लिए प्रतीक्षा करेंगी, उदाहरण के लिए, पहली कक्षा में 71 तक, और उसके बाद प्रत्येक वाक्यांश "यह कार्य करने का समय है, क्योंकि यह पहले से ही 71 है!" सीधे शब्दों में कहें, जब 71 के मूल्य का पता लगाया जाता है, तो इसे प्रत्येक वर्ग के लिए क्रमशः विधि द्वारा बुलाया जाएगा। चलो सब कुछ अलमारियों पर रख दिया।

1. स्थिति मॉडलिंग।

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

class ClassCounter //  -    . { public void Count() { //    } } 

दो अन्य कक्षाएं ( हैंडलर_आई और हैंडलर_ II नाम), जिन्हें सार्वजनिक शून्य संदेश () विधियों द्वारा घटना का जवाब देना चाहिए। प्रत्येक विधि के अनुसार, जैसा कि सहमति है।

  class Handler_I // ,    (  71)    . { public void Message() { //  using System //     Console.WriteLine(" ,   71!"); } } 

  class Handler_II { public void Message() { Console.WriteLine(",  71!"); } } 

मुझे याद दिलाएं, जब काउंटर 100 तक पहुंचता है और 71 तक पहुंचता है, तो हैंडलर_आई और हैंडलर_II कक्षाओं के लिए संदेश () तरीके काम करने चाहिए।
अब वापस ClassCounter वर्ग के लिए और काउंटर चर int i के साथ लूप के लिए एक काउंटर बनाएं।

  class ClassCounter //  -    . { public void Count() { for (int i = 0; i < 100; i++) { } } } 

पहला चरण पूरा हो गया है। हमारे पास एक काउंटर क्लास और दो कक्षाएं हैं जो संदेश प्रदर्शित करेंगी। टास्क की स्थिति: जैसे ही मैं = 71 , संदेश () दो वर्गों के लिए तरीके Handler_I और Handler_II काम करना चाहिए।

2. इवेंट डिजाइन।

हम प्रोग्रामिंग से अमूर्त हैं। जिस घटना को हम बनाना चाहते हैं वह वाक्यांश "... काउंटर मायने रखता है। और जैसे ही यह 71 होता है, क्रियाओं का प्रदर्शन किया जाना चाहिए।" इसलिए, हमें "जैसे ही यह 71 के बराबर है।" यदि कथन है तो सशर्त का उपयोग करके इसकी कल्पना करें।

  class ClassCounter //  -    . { public void Count() { for (int i = 0; i < 100; i++) { if (i == 71) { } } } } 

हम ईवेंट इवेंट बनाते हैं । हम उन तरीकों से निर्धारित करते हैं जो i = 71 पर काम करना चाहिए उनके हस्ताक्षर (या प्रोटोटाइप)।
एक विधि के हस्ताक्षर तथाकथित विनिर्देश (या, सरल शब्दों में, "टेम्पलेट") के हैं विधि या तरीके। यह उस प्रकार के नाम का एक संयोजन है जो विधि लौटती है, साथ ही इनपुट मापदंडों के प्रकार का नाम (क्रम में! यह बहुत महत्वपूर्ण है।)
उदाहरण के लिए, int NewMethod (int x, char y) विधि में हस्ताक्षर int (int, char) और शून्य NewMethod () विधि में शून्य (void) होगा ।
MSDN की व्याख्या के रूप में , घटनाओं प्रतिनिधियों पर आधारित हैं, और एक प्रतिनिधि, बहुत ही सरल शब्दों में, "एक चर एक विधि का संदर्भ संग्रहीत" है। जैसा कि आप पहले से ही समझ चुके हैं, क्योंकि हमारी घटना दो शून्य संदेश () विधियों का उल्लेख करेगी, हमें इन विधियों के हस्ताक्षर का निर्धारण करना चाहिए, और इस हस्ताक्षर के आधार पर एक प्रतिनिधि को आकर्षित करना होगा। हस्ताक्षर इस तरह दिखता है: शून्य (शून्य) ।

प्रतिनिधि को परिभाषित करें (इसे मेथोकेनटेनर कहते हैं):

  class ClassCounter //  -    . { //   ,     : //delegate < > (<  >); //   void Message().   ,   . public delegate void MethodContainer(); public void Count() { for (int i = 0; i < 100; i++) { if (i == 71) { } } } } 

अगला, हम कीवर्ड ईवेंट का उपयोग करके एक ईवेंट बनाते हैं और इसे इस डेलिगेट ( MethodContainer ) के साथ जोड़ते हैं , और इसलिए, ऐसे तरीकों के साथ जिनमें हस्ताक्षर शून्य (शून्य) हैं । घटना सार्वजनिक होनी चाहिए, क्योंकि इसका उपयोग विभिन्न वर्गों द्वारा किया जाना चाहिए जो किसी भी तरह से प्रतिक्रिया करने की आवश्यकता होती है (कक्षाएं हैंडलर_आई और हैंडलर_II)।
घटना में वाक्य रचना है: सार्वजनिक घटना <DeligentName> <EventName>;
प्रतिनिधि का नाम उस प्रतिनिधि का नाम है, जिससे हमारे तरीके संदर्भित होते हैं।

  class ClassCounter //  -    . { public delegate void MethodContainer(); // OnCount c   MethodContainer. public event MethodContainer onCount; public void Count() { for (int i = 0; i < 100; i++) { if (i == 71) { } } } } 

अब, हमारे ऑनकाउंट इवेंट को फायर करें, बशर्ते कि मैं = 71:

 if (i == 71) { onCount(); } 

वह सब है। ईवेंट बनाया गया । इस ईवेंट ट्रिगर्स के तरीकों को हस्ताक्षरों द्वारा पहचाना जाता है और उनके आधार पर एक प्रतिनिधि बनाया जाता है। यह घटना, प्रतिनिधि के आधार पर बनाई गई है। ऑनकाउंट ईवेंट को दिखाने का समय है कि आखिर किन तरीकों से काम करना चाहिए (हमने केवल उनके हस्ताक्षर निर्दिष्ट किए हैं)।

3. सदस्यता।

मुख्य कार्यक्रम प्रविष्टि बिंदु पर वापस जाएं और क्लासकाउंटर वर्ग का एक उदाहरण बनाएं। और उन वर्गों का एक उदाहरण भी बनाएं जिन्हें लॉन्च किया जाना चाहिए। (उन्हें सार्वजनिक होना चाहिए)।

  class Program { static void Main(string[] args) { ClassCounter Counter = new ClassCounter(); Handler_I Handler1 = new Handler_I(); Handler_II Handler2 = new Handler_II(); } } 

अब हम ऑनकाउंट ईवेंट इंगित करते हैं, जो विधियाँ लॉन्च की जानी चाहिए।
यह निम्नानुसार होता है: <क्लास या ऑब्जेक्ट>। ईवेंट का नाम> + = <क्लास, जिसकी विधि को प्रारंभ करना होगा> <साइन इन के लिए उपयुक्त विधि> ।
विधि के बाद कोई कोष्ठक नहीं! हम उसे नहीं कहते हैं, लेकिन केवल उसके नाम का संकेत देते हैं।

  class Program { static void Main(string[] args) { ClassCounter Counter = new ClassCounter(); Handler_I Handler1 = new Handler_I(); Handler_II Handler2 = new Handler_II(); //   Counter.onCount += Handler1.Message; Counter.onCount += Handler2.Message; } } 

की जाँच करें।

अब यह क्लासकाउंटर क्लास के काउंटर को शुरू करने के लिए बना हुआ है और जब तक मैं 71 के बराबर नहीं हो जाता, तब तक इंतजार करता हूं। जैसे ही i = 71, ऑनकाउंट इवेंट में प्रतिनिधि MethodContainer द्वारा फायर किया जाएगा, जो (बदले में) मैसेज () मेथड्स को सब्सक्राइब करेंगे जो इवेंट में सब्स्क्राइब्ड थे।

  class Program { static void Main(string[] args) { ClassCounter Counter = new ClassCounter(); Handler_I Handler1 = new Handler_I(); Handler_II Handler2 = new Handler_II(); Counter.onCount += Handler1.Message; Counter.onCount += Handler2.Message; //  Counter.Count(); } } 

परिणाम:
यह कार्य करने का समय है, क्योंकि पहले से ही 71!
वास्तव में, पहले से ही 71!

निष्कर्ष।

घटना बनाने के अर्थ और आदेश को समझने की कोशिश करें।

• 1. घटना की स्थिति और काम करने के तरीकों को परिभाषित करें।
• 2. इन विधियों के हस्ताक्षर को परिभाषित करें और इस हस्ताक्षर के आधार पर एक प्रतिनिधि बनाएं।
• 3. इस प्रतिनिधि के आधार पर एक सार्वजनिक कार्यक्रम बनाएं और जब हालत काम करे तो कॉल करें।
• 4. सुनिश्चित करें कि (कहीं भी) इस घटना के लिए उन तरीकों की सदस्यता लें जो काम करने चाहिए और जिनके हस्ताक्षर प्रतिनिधि के लिए उपयुक्त हैं।

जिस कक्षा में आप घटना (जनरेट) बनाते हैं, उसे प्रकाशक वर्ग कहा जाता है, और वे वर्ग जिनकी विधियाँ "+ =" के साथ इस घटना की सदस्यता लेती हैं, उनकी सदस्यता वाली कक्षाएं हैं।

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

  if (i == 71) { if (onCount != null) { onCount(); } } 

आप ऑपरेटर " - = ": <ClassOrObject> <EventName> - = <ClassCheyMethodMustStart> <<हस्ताक्षर के लिए उपयुक्त> का उपयोग करके हमेशा सदस्यता समाप्त कर सकते हैं।

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

सबसे छोटे के लिए, सवाल उठ सकता है: क्या करना चाहिए अगर काम करने वाले तरीकों में एक इनपुट पैरामीटर होना चाहिए (या एक से अधिक भी हो!)।
उत्तर: यह सब उस प्रतिनिधि के बारे में है जिस पर यह कार्यक्रम आधारित है। अधिक सटीक रूप से, प्रतिनिधि के लिए उपयुक्त विधियों का हस्ताक्षर। जब आप एक प्रतिनिधि बनाते हैं जो एक पैरामीटर के साथ एक विधि "स्वीकार करता है", तब (!) जब घटना शुरू होती है, तो यह इस पैरामीटर का अनुरोध करेगा। स्वाभाविक रूप से, एक पैरामीटर कुछ भी हो सकता है।

.NET इवेंट्स के बारे में कुछ शब्द। Microsoft ने प्रतिनिधियों के निर्माण के कार्य को सरल बना दिया है: .NET EventHandler, और इसी तरह एक तैयार प्रतिनिधि प्रदान करता है। EventArgs के इनपुट मापदंडों का "पैकेज"। क्या आप एक घटना चाहेंगे? समाप्त EventHandler लें, इसे मापदंडों में परिभाषित करें, उन्हें कक्षा में "पुश" करें, और EventArgs से वर्ग वार करें। और फिर - अनुसूचित के रूप में)

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

PS यदि आपने कभी प्रतिनिधियों का उपयोग नहीं किया है, तो प्रतिनिधियों पर बेहतर अभ्यास करने की कोशिश करें, और फिर इस लेख को समझने की कोशिश करें।
मुझे आशा है कि मैंने इस कठिन विषय को समझने में थोड़ा योगदान दिया है। सौभाग्य!