👆🏻 🏇🏾 📠 सी # की मूलभूत नींव को तोड़ना: स्टैक पर एक संदर्भ प्रकार के लिए मेमोरी आवंटित करना 🔳 💪 🦑

इस लेख में, आंतरिक प्रकार के डिवाइस की मूल बातें दी जाएंगी, साथ ही एक उदाहरण जिसमें संदर्भ प्रकार के लिए मेमोरी पूरी तरह से स्टैक पर आवंटित की जाएगी (यह इसलिए है क्योंकि मैं एक पूर्ण-स्टैक प्रोग्रामर हूं)।

त्याग

इस लेख में ऐसी सामग्री नहीं है जिसका उपयोग वास्तविक परियोजनाओं में किया जाना चाहिए। यह केवल सीमाओं का एक विस्तार है जिसमें एक प्रोग्रामिंग भाषा माना जाता है।

कहानी शुरू करने से पहले, मैं दृढ़ता से सलाह देता हूं कि आप स्ट्रक्चरलआउट के बारे में पहली पोस्ट पढ़ें, क्योंकि एक उदाहरण का विश्लेषण किया जाता है जिसका उपयोग इस लेख में किया जाएगा (हालांकि, हमेशा की तरह)।

प्रागितिहास

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

प्रकारों की आंतरिक संरचना के बारे में थोड़ा

मैं आपको याद दिलाना चाहूंगा कि स्टैक और ढेर पर मेमोरी का पृथक्करण .NET स्तर पर होता है, और यह विभाजन पूरी तरह से तार्किक है, शारीरिक रूप से ढेर के नीचे और स्टैक के तहत मेमोरी क्षेत्रों के बीच कोई अंतर नहीं है। उत्पादकता में अंतर पहले से ही इन क्षेत्रों के साथ काम करके प्रदान किया गया है।

फिर स्टैक पर मेमोरी कैसे आवंटित करें? शुरू करने के लिए, आइए देखें कि यह रहस्यमय संदर्भ प्रकार कैसे संरचित है और इसमें क्या है, जो महत्वपूर्ण नहीं है।

इसलिए, कर्मचारी वर्ग के साथ सबसे सरल उदाहरण पर विचार करें।

कर्मचारी कोड

public class Employee { private int _id; private string _name; public virtual void Work() { Console.WriteLine(“Zzzz...”); } public void TakeVacation(int days) { Console.WriteLine(“Zzzz...”); } public static void SetCompanyPolicy(CompanyPolicy policy) { Console.WriteLine("Zzzz..."); } }

और एक नज़र डालें कि इसे स्मृति में कैसे प्रस्तुत किया जाता है।
UPD: इस वर्ग को 32-बिट सिस्टम के उदाहरण पर माना जाता है।

इस प्रकार, फ़ील्ड के लिए मेमोरी के अलावा, हमारे पास दो और छिपे हुए फ़ील्ड हैं - सिंक्रनाइज़ेशन ब्लॉक का सूचकांक (तस्वीर में ऑब्जेक्ट का शीर्षक शब्द) और विधि तालिका का पता।

पहला क्षेत्र, यह सिंक्रनाइज़ेशन ब्लॉक का सूचकांक है, हम विशेष रूप से रुचि नहीं रखते हैं। टाइप करते समय, मैंने इसे छोड़ने का फैसला किया। मैंने ऐसा दो कारणों से किया है:

मैं बहुत आलसी हूं (मैंने यह नहीं कहा कि कारण वाजिब होंगे)
यह फ़ील्ड ऑब्जेक्ट की बुनियादी कार्यप्रणाली के लिए वैकल्पिक है।

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

दूसरा क्षेत्र हमारे लिए बहुत अधिक महत्वपूर्ण है। प्रकार के तरीकों की तालिका के लिए धन्यवाद, इस तरह के एक शक्तिशाली उपकरण बहुरूपता संभव है (जो, संयोग से, संरचना के पास नहीं है, ढेर के राजा)। मान लें कि कर्मचारी वर्ग अतिरिक्त रूप से तीन इंटरफेस लागू करता है: IComparable, IDis प्रयोज्य और ICloneable।

तब विधि तालिका कुछ इस तरह दिखाई देगी

चित्र बहुत अच्छा है, वहाँ, सिद्धांत रूप में, सब कुछ चित्रित और समझने योग्य है। यदि यह उंगलियों पर छोटा है, तो वर्चुअल विधि को सीधे पते पर नहीं, बल्कि विधि तालिका में ऑफसेट द्वारा कहा जाता है। पदानुक्रम में, एक ही वर्चुअल तरीके विधि तालिका में समान ऑफसेट पर स्थित होंगे। यही है, हम ऑफसेट पर बेस क्लास पर विधि को कॉल करते हैं, यह नहीं जानते कि किस प्रकार की विधि तालिका का उपयोग किया जाएगा, लेकिन यह जानते हुए कि इस ऑफसेट पर रनटाइम प्रकार के लिए सबसे अधिक प्रासंगिक विधि होगी।

यह भी याद रखने योग्य है कि ऑब्जेक्ट का संदर्भ विधि तालिका में इंगित करता है।

लंबे समय से प्रतीक्षित उदाहरण

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

यहाँ कोड

 //     public class PointerCasterFacade { public virtual unsafe T GetManagedReferenceByPointer<T>(int* pointer) => default(T); public virtual unsafe int* GetPointerByManagedReference<T>(T managedReference) => (int*)0; } //     public class PointerCasterUnderground { public virtual T GetManagedReferenceByPointer<T>(T reference) => reference; public virtual unsafe int* GetPointerByManagedReference<T>(int* pointer) => pointer; } [StructLayout(LayoutKind.Explicit)] public class PointerCaster { public PointerCaster() { pointerCaster= new PointerCasterUnderground(); } [FieldOffset(0)] private PointerCasterUnderground pointerCaster; [FieldOffset(0)] public PointerCasterFacade Caster; }

सबसे पहले, एक विधि लिखें जो कुछ मेमोरी में पॉइंटर लेता है (जरूरी नहीं कि स्टैक पर, वैसे) और प्रकार को कॉन्फ़िगर करता है।

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

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

वास्तव में यही सब है। अप्रत्याशित रूप से, है ना? अब हमारा प्रकार तैयार है। पिनोचियो, जिन्होंने हमें मेमोरी आवंटित की, खेतों की प्रारंभिक देखभाल का ख्याल रखेंगे।

यह केवल सूचक को प्रबंधित लिंक में बदलने के लिए ग्रैंडकास्टर का उपयोग करने के लिए बना हुआ है।

 public class StackInitializer { public static unsafe T InitializeOnStack<T>(int* pointer) where T : new() { T r = new T(); var caster = new PointerCaster().Caster; int* ptr = caster.GetPointerByManagedReference(r); pointer[0] = ptr[0]; T reference = caster.GetManagedReferenceByPointer<T>(pointer); return reference; } }

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

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

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

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

 unsafe class Program { public static void Main() { int* pointer = stackalloc int[2]; var a = StackInitializer.InitializeOnStack<StackReferenceType>(pointer); a.StubMethod(); Console.WriteLine(a.Field); Console.WriteLine(a); Console.Read(); } }

आपको वास्तविक परियोजनाओं में इसका उपयोग नहीं करना चाहिए, स्टैक पर मेमोरी आवंटित करने वाली विधि नए टी () का उपयोग करती है, जो बदले में ढेर पर प्रकार बनाने के लिए प्रतिबिंब का उपयोग करती है! तो यह विधि एक बार के सामान्य निर्माण की तुलना में धीमी होगी, अच्छी तरह से, 40-50।

यहां आप पूरे प्रोजेक्ट को देख सकते हैं।

स्रोत: एक सैद्धांतिक विषयांतर में, उदाहरणों का उपयोग साशा गोल्डस्टीन - प्रो .NET प्रोस्टेस की पुस्तक से किया गया था

सी # की मूलभूत नींव को तोड़ना: स्टैक पर एक संदर्भ प्रकार के लिए मेमोरी आवंटित करना

त्याग

प्रागितिहास

प्रकारों की आंतरिक संरचना के बारे में थोड़ा

लंबे समय से प्रतीक्षित उदाहरण

More articles: