प्रोग्रामिंग विविधता

आप अभी भी कोविर्सियस और कंट्रोवर्सी की अवधारणाओं को समझने की कोशिश नहीं कर सकते हैं? महसूस करें कि वे आपकी पीठ में कैसे सांस लेते हैं, लेकिन जब आप चारों ओर मुड़ते हैं तो आपको कुछ भी नहीं मिलता है एक उपाय है!

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

ब्रीफिंग

इस पोस्ट में विभिन्नताओं को किसी भी प्रोग्रामिंग भाषा की परवाह किए बिना समझा जाता है। अभ्यास अनुभाग में उदाहरण छद्म भाषा में लिखे गए हैं (यह चमत्कारिक रूप से C # के समान निकला) और इसलिए आपके पसंदीदा संकलक द्वारा संकलित किए जाने की आवश्यकता नहीं है। चलिए शुरू करते हैं।

शब्दावली के टोटके

प्रलेखन, तकनीकी साहित्य और अन्य स्रोतों में, आप विभिन्न घटनाओं के लिए अलग-अलग नामों से आ सकते हैं। कोई ज्यादा डरा और सहमा हुआ।

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

अंग्रेजी में, सब कुछ सरल है - सहसंयोजक और विरोधाभासी।

सिद्धांत

वेरिएंट - स्रोत प्रकारों की विरासत को व्युत्पन्न प्रकारों में स्थानांतरित करना। व्युत्पन्न प्रकारों का मतलब कंटेनरों, प्रतिनिधियों, सामान्यीकरणों से समझा जाता है, न कि पूर्वज-बाल संबंधों से जुड़े प्रकारों से। विभिन्न प्रकार की भिन्नता कोविरियस, कंट्रोवर्सी और इनविरेन्स हैं।

कोवरियनस - प्रत्यक्ष प्रकारों में स्रोत प्रकारों की विरासत को व्युत्पन्न प्रकारों में स्थानांतरित करना।
विपरीतार्थक - स्रोत प्रकारों की विरासत को उल्टे क्रम में उनसे व्युत्पन्न प्रकारों में स्थानांतरित करना।
Invariance एक ऐसी स्थिति है जहां मूल प्रकार की विरासत को व्युत्पन्न में स्थानांतरित नहीं किया जाता है।

यदि व्युत्पन्न प्रकार सहसंयोजक दिखाते हैं, तो उन्हें मूल प्रकार के सहसंयोजक कहा जाता है। यदि व्युत्पन्न प्रकार कंट्राविरेंट हैं, तो उन्हें मूल प्रकार के विपरीत कहा जाता है। यदि व्युत्पन्न प्रकार एक या दूसरे का निरीक्षण नहीं करते हैं, तो उन्हें अपरिवर्तनीय कहा जाता है।

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

अभ्यास

यह सब किस लिए है?

परिवर्तनशीलता का पूरा बिंदु व्युत्पन्न प्रकारों में विरासत का लाभ उठाना है। यह ज्ञात है कि यदि दो प्रकार पूर्वज-बाल संबंध से संबंधित हैं, तो वंश वस्तु को पूर्वज प्रकार के चर में संग्रहीत किया जा सकता है। व्यवहार में, इसका मतलब है कि हम पूर्वजों की वस्तुओं के बजाय कुछ कार्यों के लिए वंशज वस्तुओं का उपयोग कर सकते हैं। इस प्रकार, एक सामान्य पूर्वज के साथ विभिन्न वंशजों द्वारा समर्थित कार्यों को करने के लिए अधिक लचीला और छोटा कोड लिखना संभव है।

स्रोत पदानुक्रम और व्युत्पन्न प्रकार

शुरू करने के लिए, हम उस प्रकार के पदानुक्रम का वर्णन करते हैं जिसके साथ हम काम करेंगे। पदानुक्रम के शीर्ष पर हमारे पास Device (डिवाइस) है, जिसके वंशज Mouse (माउस), Keyboard (कीबोर्ड) हैं। Mouse बदले में, वंशज भी हैं - WiredMouse (वायर्ड माउस), WiredMouse (वायरलेस माउस)।

सभी को कंटेनर पसंद हैं। उनके उदाहरण का उपयोग करना, यह समझाने के लिए सबसे सरल है कि व्युत्पन्न प्रकारों का क्या मतलब है। यदि हम सूचियों को व्युत्पन्न प्रकारों के बारे में बात करते हैं, तो Device प्रकार के लिए व्युत्पन्न होगा
List<Device> (उपकरणों की सूची)। इसी प्रकार, Keyboard प्रकार के लिए, List<Keyboard> व्युत्पन्न है। मुझे लगता है, अगर संदेह थे, अब वे चले गए हैं।

क्लासिक सहसंयोजक

कंटेनरों के साथ सहसंयोजक सीखना भी आसान है। ऐसा करने के लिए, पदानुक्रम (शाखा) के एक भाग का चयन करें - Keyboard : Device (कीबोर्ड एक उपकरण है, कीबोर्ड डिवाइस का एक विशेष मामला है)। फिर से, सूचियों को लें और सहसंयोजक व्युत्पन्न शाखा का निर्माण करें - List<Keyboard> : List<Device> (कीबोर्ड की सूची उपकरणों की सूची का एक विशेष मामला है)। जैसा कि आप देख सकते हैं, विरासत को सीधे क्रम में स्थानांतरित किया गया था।

एक कोड उदाहरण पर विचार करें। एक फ़ंक्शन है जो उपकरणों की List<Device> लेता है List<Device> और उन पर कुछ हेरफेर करता है। जैसा कि आप अनुमान लगा सकते हैं, आप इस समारोह में कीबोर्ड List<Keyboard> की सूची पास कर सकते हैं:

 void DoSmthWithDevices(List<Device> devices) { /*     */ } ... List<Keyboard> keyboards = new List<Keyboard> { /*   */ }; DoSmthWithDevices(keyboards); 

शास्त्रीय विरोधाभासी

कंट्रोवर्सी के अध्ययन के लिए विहित इसके प्रतिनिधियों के आधार पर विचार करता है। मान लीजिए कि हमारे पास एक सामान्य प्रतिनिधि है:

 delegate void Action<T>(T something); 

प्रारंभिक प्रकार के Device व्युत्पन्न Action<Device> , और Keyboard , Action<Keyboard> । प्राप्त प्रतिनिधि क्रमशः उन कार्यों का प्रतिनिधित्व कर सकते हैं जो डिवाइस या माउस पर किसी प्रकार की कार्रवाई करते हैं। Keyboard : Device शाखा, हम एक व्युत्पन्न कंट्रावेरिएंट शाखा का निर्माण करते हैं - Action<Device> : Action<Keyboard> (किसी डिवाइस पर एक्शन Action<Device> : Action<Keyboard> पर एक्शन का एक विशेष मामला है - यह अजीब लगता है, लेकिन यह है)। यदि आप कीबोर्ड पर कुंजी दबा सकते हैं, तो इसका मतलब यह नहीं है कि आप इसे डिवाइस पर दबा सकते हैं (यह कुंजी क्या है इसका कोई सुराग नहीं हो सकता है)। लेकिन अगर आप डिवाइस को कनेक्ट कर सकते हैं, तो आप कीबोर्ड को उसी तरीके से कनेक्ट कर सकते हैं (विधि, फ़ंक्शन)। जैसा कि आप देख सकते हैं, विरासत को रिवर्स ऑर्डर में स्थानांतरित किया गया था।

पूर्वगामी से, यह तर्कसंगत है कि यदि कोई फ़ंक्शन डिवाइस पर कुछ प्रदर्शन कर सकता है, तो वह कीबोर्ड पर भी यह प्रदर्शन कर सकता है। इसका मतलब है कि हम एक Action<Device> डेलीगेट ऑब्जेक्ट को एक फंक्शन में पास कर सकते हैं जो Action<Keyboard> डेलीगेट ऑब्जेक्ट को स्वीकार करता है। कोड पर विचार करें:

 void DoSmthWithKeyboard(Action<Keyboard> actionWithKeyboard) { /*  actionWithKeyboard   */ } ... Action<Device> actionWithDevice = device => device.PlugIn(); DoSmthWithKeyboard(actionWithDevice); 

जरा-सी असावधानी

यदि व्युत्पन्न प्रकार मूल प्रकारों के लिए अपरिवर्तनीय हैं, तो Keyboard : Device शाखा न तो सहसंयोजक ( List<Keyboard> : List<Device> ) और न ही एक contravariant ( Action<Device> : Action<Keyboard> ) शाखा बनती है। इसका अर्थ है कि व्युत्पन्न प्रकारों के बीच कोई संबंध नहीं है। जैसा कि आप देख सकते हैं, विरासत को स्थानांतरित नहीं किया गया है।

क्या होगा अगर?

असभ्य सहसंयोजक

टाइप Action<T> प्रतिनिधि Action<T> सहसंयोजक हो सकते हैं। इसका अर्थ है कि Keyboard : Device शाखा के लिए, एक सहसंयोजक शाखा बनती है - Action<Keyboard> : Action<Device> । इस प्रकार, एक Action<Keyboard> डेलीगेट ऑब्जेक्ट को एक फंक्शन पास किया जा सकता है जो Action<Device> डेलीगेट ऑब्जेक्ट को स्वीकार करता है।

 void DoSmthWithDevice(Action<Device> actionWithDevice) { /*  actionWithDevice   */ } ... Action<Keyboard> actionWithKeyboard = keyboard => ((Device)keyboard).PlugIn(); DoSmthWithDevice(actionWithKeyboard); 

असभ्य विरोधाभासी

कंटेनर कंट्रावेरेंट हो सकते हैं। इसका मतलब है कि Keyboard : Device शाखा के लिए, एक कंट्रावेरेंट शाखा का गठन किया जाता है - List<Device> : List<Keyboard> । इस प्रकार, एक List<Keyboard> में, जो कि एक List<Keyboard> लेता है, आप एक List<Device> पास कर सकते हैं:

 void FillListWithKeyboards(List<Keyboard> keyboards) { /*    */ } ... List<Devices> devices = new List<Devices>(); FillListWithKeyboards(devices); 

पवित्र अर्थ

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

कंटेनर सुरक्षा

यदि व्युत्पन्न प्रकार सहसंयोजक है, तो कंटेनर को केवल सुरक्षा सुनिश्चित करने के लिए पढ़ा जाना चाहिए। अन्यथा, List<Keyboard> को कास्टिंग के माध्यम से List<Keyboard> में गलत प्रकार ( Device , Mouse और अन्य) का ऑब्जेक्ट लिखना संभव है।

 List<Device> devices = new List<Keyboard>(); devices.Add(new Device()); //    

यदि व्युत्पन्न प्रकार कॉन्ट्रैवियर है, तो सुरक्षा कारणों से कंटेनर को केवल लिखा जाना चाहिए। अन्यथा, List<Device> से संबंधित सूची ( List<Keyboard> , List<Mouse> और अन्य) पर कास्टिंग करके गलत प्रकार ( Keyboard , Mouse और अन्य) की एक वस्तु को पढ़ना संभव है।

 List<Keyboard> keyboards = new List<Device>(); keyboards.Add(new Keyboard()); keyboards[0].PressSpace(); //    

प्रतिनिधियों के लिए दोहरा मापदंड

प्रतिनिधियों के लिए उचित परिणाम आउटपुट मान के लिए सहसंयोजक है और इनपुट मापदंडों (संदर्भ से गुजरते हुए) को छोड़कर। यदि ये स्थितियाँ पूरी होती हैं, तो रनटाइम त्रुटियाँ उत्पन्न नहीं होती हैं।

डीब्रीफिंग

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

यूडीपी

शायद भिन्नता की अधिक सही परिभाषा एरिक लिपर्ट द्वारा प्रस्तावित है। लेख के लिंक के लिए Alex_sik को धन्यवाद।

असाइनमेंट संगतता अधिक सामान्य प्रकार के संगत चर में अधिक निजी प्रकार के मूल्य को असाइन करने की क्षमता है।
भिन्न प्रकारों को व्युत्पन्न प्रकारों के असाइनमेंट की संगतता का संरक्षण है।
कोवरियनस प्रत्यक्ष क्रम में डेरिवेटिव में स्रोत प्रकारों के असाइनमेंट की संगतता का संरक्षण है।
विपरीत क्रम में व्युत्पन्न में मूल प्रकारों के असाइनमेंट की संगतता का संरक्षण है।