👺 🤚🏻 👩🏼‍⚖️ सी # की बुनियादी बातों को तोड़कर: स्टैक पर एक संदर्भ प्रकार के लिए मेमोरी आवंटित करना 🔵 🧕🏻 👩🏼‍✈️

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

त्याग

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

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

प्रागितिहास

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

थोड़े प्रकार के इंटर्नल्स के बारे में (पुराने ढांचे के लिए, अब कुछ ऑफसेट बदल दिए गए हैं, लेकिन कुल मिलाकर स्कीमा समान है)

मैं याद दिलाना चाहूंगा कि मेमोरी का एक स्टैक और ढेर में विभाजन .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..."); } }

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

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

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

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

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

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

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

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

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

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

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

मैपर का कोड

 // Provides the signatures we need public class PointerCasterFacade { public virtual unsafe T GetManagedReferenceByPointer<T>(int* pointer) => default(T); public virtual unsafe int* GetPointerByManagedReference<T>(T managedReference) => (int*)0; } // Provides the logic we need 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: