🌞 👩‍❤️‍💋‍👨 👍🏽 वास्तविक समुराई के लिए एनकैप्सुलेशन, या C # में आंतरिक कीवर्ड से जुड़ी बारीकियां 🕎 🤱 👨🏻‍🌾

प्रस्तावना: आंतरिक नया सार्वजनिक है

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

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

आक्रामक बुनियादी मदद

पूरी तरह से याद दिलाने और लेबल करने के लिए।

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

यूनिट टेस्ट और फ्रेंडली बिल्ड

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

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

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

और यहाँ, मेरी स्मृति के डिब्बे में कहीं से, अनुकूल विधानसभाओं के बारे में कुछ प्राप्त हुआ था। यह पता चला कि अगर आपके पास असेंबली "YourAssemblyName" है, तो आप इस तरह लिख सकते हैं:

[assembly: InternalsVisibleTo("YourAssemblyName.Tests")]

और असेंबली "YourAssemblyName.Tests" यह देखेगा कि "YourAssemblyName" में आंतरिक कीवर्ड के साथ क्या चिह्नित है। यह लाइन असेंबलीइन्फो.के में थोड़ी-सी दर्ज की जा सकती है, जिसे वीएस विशेष रूप से ऐसी विशेषताओं को संग्रहीत करने के लिए बनाता है।

मूल मदद के लिए अपमानजनक लौटें

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

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

मैं लगभग एक महत्वपूर्ण बिंदु भूल गया। विशेषता कार्रवाई InternalsVanishTo एक तरफ़ा है।

संरक्षित <आंतरिक?

तो स्थिति: A और B एक पाइप पर बैठे थे।

 using System; namespace Pipe { public class A { public String SomeProperty { get; protected set; } } internal class B { //ERROR!!! The accessibility modifier of the 'B.OtherProperty.set' accessor must be more //restrictive than the property or indexer 'B.OtherProperty' internal String OtherProperty { get; protected set; } } }

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

मूल रूप से, त्रुटि संदेश तार्किक है। प्रॉपर्टी ऐक्सेसर प्रॉपर्टी से ज्यादा का खुलासा नहीं कर सकता है। यदि कंपाइलर इसके लिए हेडर देता है तो कोई भी इसे समझने के लिए प्रतिक्रिया देगा:

 internal String OtherProperty { get; public set; }

लेकिन इस रेखा के दावे तुरंत मस्तिष्क को तोड़ देते हैं:

 internal String OtherProperty { get; protected set; }

मैं ध्यान देता हूं कि इस लाइन के बारे में कोई शिकायत नहीं होगी:

 internal String OtherProperty { get; private set; }

यदि आप अधिक नहीं सोचते हैं, तो निम्न पदानुक्रम आपके सिर में बनाया गया है:

 public > internal > protected > private

और यह पदानुक्रम भी काम करने लगता है। सिवाय एक जगह के। जहां आंतरिक> संरक्षित। संकलक के दावों के सार को समझने के लिए, आइए याद करें कि आंतरिक और संरक्षित द्वारा क्या प्रतिबंध लगाए गए हैं। आंतरिक - केवल विधानसभा के अंदर। संरक्षित - केवल वारिस। किसी भी वारिस को नोटिस करें। और यदि वर्ग बी को सार्वजनिक रूप से चिह्नित किया जाता है, तो किसी अन्य विधानसभा में आप इसके वंशजों को परिभाषित कर सकते हैं। और फिर सेट एक्सेसर वास्तव में उस जगह तक पहुंच जाता है जहां पूरी संपत्ति नहीं है। चूँकि C # कंपाइलर पैरानॉयड है, इसलिए यह इस तरह की संभावना की अनुमति भी नहीं दे सकता है।

इसके लिए उसके लिए धन्यवाद, लेकिन हमें वारिस को एक्सेसर तक पहुंचाने की आवश्यकता है। और विशेष रूप से ऐसे मामलों के लिए, एक संरक्षित आंतरिक पहुंच संशोधक है।

यह मदद इतनी आक्रामक नहीं है

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

इसलिए यदि हम चाहते हैं कि कंपाइलर हमें इस संपत्ति का उपयोग करने और वारिस में सेट करने की अनुमति दे, तो हमें यह करने की आवश्यकता है:

 using System; namespace Pipe { internal class B { protected internal String OtherProperty { get; protected set; } } }

और एक्सेस संशोधक की सही पदानुक्रम कुछ इस तरह दिखती है:

 public > protected internal > internal/protected > private

इंटरफेस

तो, स्थिति: A, I, B पाइप पर बैठे थे।

 namespace Pipe { internal interface I { void SomeMethod(); } internal class A : I { internal void SomeMethod() { //'A' does not implement interface member 'I.SomeMethod()'. //'A.SomeMethod()' cannot implement an interface member because it is not public. } } internal class B : I { internal void SomeMethod() { //'B' does not implement interface member 'I.SomeMethod()'. //'B.SomeMethod()' cannot implement an interface member because it is not public. } } }

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

और हमारे पास दो रास्ते हैं। पहला: दांतों की क्रेक और गेनिंग के माध्यम से, इंटरफ़ेस के कार्यान्वयन पर एक सार्वजनिक एक्सेस संशोधक लटकाएं। दूसरा: इंटरफ़ेस का स्पष्ट कार्यान्वयन। यह इस तरह दिखता है:

 namespace Pipe { internal interface I { void SomeMethod(); } internal class A : I { public void SomeMethod() { } } internal class B : I { void I.SomeMethod() { } } }

कृपया ध्यान दें कि दूसरे मामले में कोई एक्सेस संशोधक नहीं है। इस मामले में किसके लिए विधि का कार्यान्वयन उपलब्ध है? चलो बस कोई नहीं कहता। एक उदाहरण के साथ दिखाना आसान है:

 B b = new B(); //'B' does not contain a definition for 'SomeMethod' and no accessible extension method //'SomeMethod' accepting a first argument of type 'B' could be found //(are you missing a using directive or an assembly reference?) b.SomeMethod(); //OK (b as I).SomeMethod();

इंटरफ़ेस के स्पष्ट कार्यान्वयन का मतलब है कि जब तक हम स्पष्ट रूप से I टाइप करने के लिए चर नहीं डालते हैं, तब तक इस इंटरफ़ेस को लागू करने वाले कोई तरीके नहीं हैं। लेखन (बी मैं के रूप में)। कुछ समय () हर बार एक अधिभार हो सकता है। जैसे (I) b) .SomeMethod ()। और मुझे इसके चारों ओर जाने के दो रास्ते मिले। मैंने एक के बारे में सोचा, और दूसरे को ईमानदारी से समझा।

पहला तरीका कारखाना है:

  internal class Factory { internal I Create() { return new B(); } }

खैर, या कोई अन्य पैटर्न जो आपको इस बारीकियों को छिपाने की अनुमति देता है।

विधि दो - विस्तार विधियाँ:

  internal static class IExtensions { internal static void SomeMethod(this I i) { i.SomeMethod(); } }

हैरानी की बात है, यह काम करता है। ये पंक्तियाँ किसी त्रुटि को रोकती हैं:

 B b = new B(); b.SomeMethod();

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

लेकिन एक कैवेट रहता है। कक्षा के अंदर, आपको इस कीवर्ड के माध्यम से इस विधि को एक्सेस करने की आवश्यकता है, अन्यथा कंपाइलर यह नहीं समझ पाएंगे कि हम एक्सटेंशन को संदर्भित करना चाहते हैं:

  internal class B : I { internal void OtherMethod() { //Error!!! SomeMethod(); //OK this.SomeMethod(); } void I.SomeMethod() { } }

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

प्रतिबिंब

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

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

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

यह प्रतिबिंब के साथ समाप्त हो सकता है, लेकिन चलो पिछले उदाहरण पर लौटते हैं, जहां ए, आई, बी एक पाइप पर बैठे थे:

 namespace Pipe { internal interface I { void SomeMethod(); } internal static class IExtensions { internal static void SomeMethod(this I i) { i.SomeMethod(); } } internal class A : I { public void SomeMethod() { } internal void OtherMethod() { } } internal class B : I { internal void OtherMethod() { } void I.SomeMethod() { } } }

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

और फिर दरवाजा खुलता है और चुपचाप रेंगने का प्रतिबिंब:

 using Pipe; using System; using System.Reflection; namespace EncapsulationTest { public class Program { public static void Main(string[] args) { FindThroughReflection(typeof(I), "SomeMethod"); FindThroughReflection(typeof(IExtensions), "SomeMethod"); FindThroughReflection(typeof(A), "SomeMethod"); FindThroughReflection(typeof(A), "OtherMethod"); FindThroughReflection(typeof(B), "SomeMethod"); FindThroughReflection(typeof(B), "OtherMethod"); Console.ReadLine(); } private static void FindThroughReflection(Type type, String methodName) { MethodInfo methodInfo = type.GetMethod(methodName); if (methodInfo != null) Console.WriteLine($"In type {type.Name} we found {methodInfo}"); else Console.WriteLine($"NULL! Can't find method {methodName} in type {type.Name}"); } } }

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

प्रकार में मुझे Void SomeMethod () मिला
शून्य! टाइप IExtensions में विधि SomeMethod नहीं मिल सकता है
प्रकार A में हमने Void SomeMethod () पाया
शून्य! प्रकार A में अन्य OtherMethod विधि नहीं ढूँढ सकता
शून्य! टाइप B में मेथडमेथोड को विधि नहीं मिल सकती
शून्य! टाइप B में मेथड अन्य मेथोड नहीं ढूँढ सकते

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

किस प्रकार और किस प्रकार की प्रणाली को ध्यान से देखें। प्रकार आप दूर दे रहे हैं।

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

हमारे पाइप के मेटाडेटा में खरगोश के छेद पर एक नज़र डालें

असेंबली को रिलीज़ में इकट्ठा किया गया था

TypeDef #2 (02000003)
-------------------------------------------------------
TypDefName: Pipe.I (02000003)
Flags : [NotPublic] [AutoLayout] [Interface] [Abstract] [AnsiClass] (000000a0)
Extends : 01000000 [TypeRef]
Method #1 (06000004)
-------------------------------------------------------
MethodName: SomeMethod (06000004)
Flags : [Public] [Virtual] [HideBySig] [NewSlot] [Abstract] (000005c6)
RVA : 0x00000000
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

TypeDef #3 (02000004)
-------------------------------------------------------
TypDefName: Pipe.IExtensions (02000004)
Flags : [NotPublic] [AutoLayout] [Class] [Abstract] [Sealed] [AnsiClass] [BeforeFieldInit] (00100180)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000005)
-------------------------------------------------------
MethodName: SomeMethod (06000005)
Flags : [Assem] [Static] [HideBySig] [ReuseSlot] (00000093)
RVA : 0x00002134
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
ReturnType: Void
1 Arguments
Argument #1: Class Pipe.I
1 Parameters
(1) ParamToken : (08000004) Name : i flags: [none] (00000000)
CustomAttribute #1 (0c000011)
-------------------------------------------------------
CustomAttribute Type: 0a000001
CustomAttributeName: System.Runtime.CompilerServices.ExtensionAttribute :: instance void .ctor()
Length: 4
Value : 01 00 00 00 > <
ctor args: ()

CustomAttribute #1 (0c000010)
-------------------------------------------------------
CustomAttribute Type: 0a000001
CustomAttributeName: System.Runtime.CompilerServices.ExtensionAttribute :: instance void .ctor()
Length: 4
Value : 01 00 00 00 > <
ctor args: ()

TypeDef #4 (02000005)
-------------------------------------------------------
TypDefName: Pipe.A (02000005)
Flags : [NotPublic] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit] (00100000)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000006)
-------------------------------------------------------
MethodName: SomeMethod (06000006)
Flags : [Public] [Final] [Virtual] [HideBySig] [NewSlot] (000001e6)
RVA : 0x0000213c
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

Method #2 (06000007)
-------------------------------------------------------
MethodName: OtherMethod (06000007)
Flags : [Assem] [HideBySig] [ReuseSlot] (00000083)
RVA : 0x0000213e
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

Method #3 (06000008)
-------------------------------------------------------
MethodName: .ctor (06000008)
Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)
RVA : 0x00002140
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

InterfaceImpl #1 (09000001)
-------------------------------------------------------
Class : Pipe.A
Token : 02000003 [TypeDef] Pipe.I

TypeDef #5 (02000006)
-------------------------------------------------------
TypDefName: Pipe.B (02000006)
Flags : [NotPublic] [AutoLayout] [Class] [AnsiClass] [BeforeFieldInit] (00100000)
Extends : 01000011 [TypeRef] System.Object
Method #1 (06000009)
-------------------------------------------------------
MethodName: OtherMethod (06000009)
Flags : [Assem] [HideBySig] [ReuseSlot] (00000083)
RVA : 0x00002148
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

Method #2 (0600000a)
-------------------------------------------------------
MethodName: Pipe.I.SomeMethod (0600000A)
Flags : [Private] [Final] [Virtual] [HideBySig] [NewSlot] (000001e1)
RVA : 0x0000214a
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

Method #3 (0600000b)
-------------------------------------------------------
MethodName: .ctor (0600000B)
Flags : [Public] [HideBySig] [ReuseSlot] [SpecialName] [RTSpecialName] [.ctor] (00001886)
RVA : 0x0000214c
ImplFlags : [IL] [Managed] (00000000)
CallCnvntn: [DEFAULT]
hasThis
ReturnType: Void
No arguments.

MethodImpl #1 (00000001)
-------------------------------------------------------
Method Body Token : 0x0600000a
Method Declaration Token : 0x06000004

InterfaceImpl #1 (09000002)
-------------------------------------------------------
Class : Pipe.B
Token : 02000003 [TypeDef] Pipe.I

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

लेकिन यह, ज़ाहिर है, अगले स्तर पर, सभी स्थानों में कीवर्ड आंतरिक के उपयोग के बाद जहां जनता की कोई आवश्यकता नहीं है।

पुनश्च

आपको पता है कि विधानसभा के अंदर हर जगह आंतरिक कीवर्ड का उपयोग करने के बारे में सबसे अच्छी बात है? जब यह बढ़ता है, तो आपको इसे दो या अधिक में विभाजित करना होगा। और इस प्रक्रिया में आपको कुछ प्रकारों को खोलने के लिए ब्रेक लेना होगा। और आपको यह सोचना होगा कि कौन से प्रकार खुले होने के योग्य हैं। कम से कम संक्षेप में।

इसका अर्थ निम्न है: कोड लिखने का यह अभ्यास आपको फिर से सोचने पर मजबूर करेगा कि नवजात असेंबली के बीच वास्तुशिल्प सीमा क्या आकार लेगी। इससे ज्यादा खूबसूरत और क्या हो सकता है?

पी पी एस

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

वास्तविक समुराई के लिए एनकैप्सुलेशन, या C # में आंतरिक कीवर्ड से जुड़ी बारीकियां