👨🏿‍🚀 ♻️ 🎍 सीएलआर वस्तुओं के आकार। सटीक परिभाषा 👩🏽‍🎤 👨🏿‍🤝‍👨🏾 ⬆️

मुझे लगता है कि प्रबंधित कोड पर कई डेवलपर्स हमेशा इस बात में रुचि रखते हैं: किसी ऑब्जेक्ट पर कितने बाइट्स का एक उदाहरण होता है? और सीएलआर में किसी वस्तु का आकार सीमा क्या है? क्या 32-बिट और 64-बिट सिस्टम के बीच मेमोरी आवंटन में कोई अंतर है? यदि ये प्रश्न आपके लिए एक खाली वाक्यांश नहीं है, तो कृपया, बिल्ली के नीचे।

प्रस्तावना

सबसे पहले, याद रखें कि .NET में 2 प्रकार की वस्तुएं हैं: मूल्य प्रकार और संदर्भ प्रकार , जो क्रमशः स्टैक और हीप (कचरा कलेक्टर द्वारा प्रबंधित) पर बनाए जाते हैं।
मूल्य प्रकार सरल डेटा स्टोर करने के लिए डिज़ाइन किए गए हैं, यह एक संख्या, एक चरित्र है। किसी वैरिएबल पर मान निर्दिष्ट करते समय, प्रत्येक ऑब्जेक्ट फ़ील्ड की प्रतिलिपि बनाई जाती है। साथ ही, ऐसी वस्तुओं का जीवनकाल कार्यक्षेत्र पर निर्भर करता है। सामान्य प्रकार प्रणाली में मूल्य प्रकारों के आयाम परिभाषित किए गए हैं और इनमें शामिल हैं:

CTS प्रकार	बाइट्स की संख्या
System.Byte	1
System.SByte	1
System.Int16	2
System.Int32	4
System.Int64	8
System.UInt16	2
System.UInt32	4
System.UInt64	8
System.Single	4
System.Double	8
System.Char	2
System.Decimal	16

संदर्भ प्रकार, इसके विपरीत, एक ढेर पर किसी वस्तु के उदाहरण द्वारा कब्जा की गई स्मृति के क्षेत्र का संदर्भ है।

निम्नलिखित सीएलआर वस्तुओं की आंतरिक संरचना है:

चर संदर्भ प्रकारों के लिए, एक निश्चित-आकार का मूल्य (4 बाइट्स, टाइप DWORD) जिसमें एक नियमित हीप में बनाई गई वस्तु के उदाहरण का पता होता है (बड़े ऑब्जेक्ट हीप, हाईफ्रिक्वेंसीहाइप आदि) स्टैक पर धकेल दिए जाते हैं, लेकिन हम उन पर ध्यान केंद्रित नहीं करेंगे। )। उदाहरण के लिए, C ++ में, इस मान को ऑब्जेक्ट के लिए पॉइंटर कहा जाता है, और .NET दुनिया में, इसे ऑब्जेक्ट का संदर्भ कहा जाता है।

प्रारंभ में, सिंकब्लॉक का मूल्य शून्य है। हालाँकि, ऑब्जेक्ट का हैश कोड SyncBlock (GetHashCode पद्धति को कॉल करते समय), या सिंकब्लॉक रिकॉर्ड संख्या में संग्रहीत किया जा सकता है, जो सिंक्रनाइज़ेशन के दौरान ऑब्जेक्ट हेडर में पर्यावरण को डालता है ( लॉक का उपयोग करके, या सीधे मॉनिटर ।Eterter )।

प्रत्येक प्रकार का अपना MethodTable है, और एक ही प्रकार की वस्तुओं के सभी उदाहरण एक ही MethodTable को संदर्भित करते हैं। यह तालिका स्वयं प्रकार (इंटरफ़ेस, अमूर्त वर्ग, आदि) के बारे में जानकारी संग्रहीत करती है।

रेफरेंस टाइप पॉइंटर - ऑफसेट 4 के साथ स्टैक पर रखे गए वैरिएबल में संग्रहित किसी ऑब्जेक्ट का संदर्भ।
बाकी वर्ग क्षेत्र हैं।

मुसीबत का इशारा

हम सिद्धांत से अभ्यास करने के लिए पास करते हैं। मानक सीएलआर उपकरण का उपयोग करके किसी वस्तु का आकार निर्धारित करना संभव नहीं है। हां, C # में एक आकार का ऑपरेटर है, लेकिन इसका उद्देश्य अप्रबंधित वस्तुओं के आकार, साथ ही साथ मूल्य प्रकारों के आकार को निर्धारित करना है। संदर्भ प्रकारों के प्रश्नों में - बेकार है।

इन उद्देश्यों के लिए, दृश्य स्टूडियो डीबगर - एसओएस (स्ट्राइक का बेटा) का एक विस्तार है।

आरंभ करने से पहले, आपको अनवांटेड कोड डीबगिंग को सक्षम करना होगा:

डिबगिंग के दौरान एसओएस को सक्रिय करने के लिए, वीएस> डिबग> विंडोज> तत्काल विंडो खोलें और निम्नलिखित दर्ज करें:

.load sos.dll

जिसके बाद हम इसका सफल डाउनलोड देखेंगे:

एसओएस के पास बड़ी संख्या में टीमें हैं। हमारे मामले में, केवल निम्नलिखित की आवश्यकता होगी:

! DumpStackObjects (! DSO) - वर्तमान स्टैक के भीतर पता चला वस्तुओं की एक सूची प्रदर्शित करता है
! DumpObj (! DO) - निर्दिष्ट पते पर वस्तु के बारे में जानकारी प्रदर्शित करता है
! ObjSize - वस्तु का पूर्ण आकार लौटाता है। थोड़ी देर बाद हम इसके उद्देश्य पर विचार करेंगे

टाइप करके अन्य कमांड पाई जा सकती हैं ! मदद

प्रदर्शित करने के लिए, हम एक सरल कंसोल एप्लिकेशन बनाएंगे और MyExampleClass क्लास लिखेंगे :

 class MyExampleClass { byte ByteValue = 255; // 1  sbyte SByteValue = 127; // 1  char CharValue = 'a'; // 2  short ShortValue = 128; // 2  ushort UShortValue = 65000; // 2  int Int32Value = 255; // 4  uint UInt32Value = 255; // 4  long LongValue = 512; // 8  ulong ULongValue = 512; // 8  float FloatValue = 128F; // 4  double DoubleValue = 512D; // 8  decimal DecimalValue = 10M; // 16  string StringValue = "String"; // 4  }

एक कैलकुलेटर लें और कक्षा के एक उदाहरण के लिए अनुमानित आकार की गणना करें - अभी के लिए, 64 बाइट्स।

हालांकि, वस्तुओं की संरचना के बारे में लेख की शुरुआत में याद रखें? तो अंतिम आकार के बराबर होगा:
सीएलआर ऑब्जेक्ट = सिंकब्लॉक (4) + टाइपहैंडल (4) + फील्ड्स (64) = 72

सिद्धांत की जाँच करें।
निम्नलिखित कोड जोड़ें:

 class Program { static void Main(string[] args) { var myObject = new MyExampleClass(); Console.ReadKey(); //  breakpoint } }

और डिबगिंग (F5) चलाएं।
तत्काल विंडो में निम्नलिखित कमांड दर्ज करें:

.load sos.dll
!DSO

ऊपर स्क्रीनशॉट में, myObject ऑब्जेक्ट का पता हाइलाइट किया गया है, जिसे हम एक पैरामीटर के रूप में पास करेंगे। "कमांड:"

खैर, myObject का आकार 72 बाइट्स है। है ना?
जवाब है नहीं। तथ्य यह है कि हम स्ट्रिंग स्ट्रिंग आकार जोड़ना भूल गए। इसका 4 बाइट्स केवल एक संदर्भ है। और यहां हम अब सही आकार की जांच करेंगे।

कमांड दर्ज करते हैं!

तो myObject का वास्तविक आकार 100 बाइट्स है।

अतिरिक्त 28 बाइट्स StringValue चर द्वारा लिया जाता है।

हालाँकि, हम इसे सत्यापित करेंगे। ऐसा करने के लिए, StringValue 01b8c008 चर के पते का उपयोग करें:

System.String का आकार क्या है?

सबसे पहले, सीटीएस में, वर्ण (प्रकार System.Char ) को यूनिकोड में दर्शाया गया है और 2 बाइट्स पर कब्जा किया गया है।

दूसरे, एक स्ट्रिंग वर्णों से अधिक कुछ नहीं है। इसलिए StringValue में हमने मूल्य "स्ट्रिंग" लिखा, जो 12 बाइट्स है।

तीसरा, System.String एक संदर्भ प्रकार है, जिसका अर्थ है कि यह GC Heap में स्थित है, और इसमें SyncBlock, TypeHandle, Reference point + वर्ग के अन्य क्षेत्र शामिल होंगे। संदर्भ बिंदु को यहां ध्यान में नहीं रखा जाएगा, क्योंकि पहले से ही वर्ग MyExampleClass (संदर्भ 4 बाइट्स) में गिना जाता है।

चौथा, System.String की संरचना इस प्रकार है:

अतिरिक्त वर्ग फ़ील्ड Int_ प्रकार के डायनामिक वैरिएबल होते हैं Int32 (4 बाइट्स), m_firstChar का प्रकार चार (2 बाइट), खाली चर नहीं माना जाएगा, क्योंकि एक खाली स्थिर स्ट्रिंग है।

पहले की गणना 28 के बजाय 26 बाइट्स के आकार पर भी ध्यान दें। यह सब एक साथ रखो:
StringValue = SyncBlock (4) + टाइपहैंडल (4) + m_stringLength (4) + m_firstChar (2) + "स्ट्रिंग" (12) = 26

एक अतिरिक्त 2 बाइट्स सीएलआर मेमोरी मैनेजर द्वारा निर्मित संरेखण के कारण बनाए जाते हैं।

x86 बनाम 64

मुख्य अंतर DWORD का आकार है - मेमोरी पॉइंटर। 32-बिट सिस्टम पर, यह 4 बाइट्स है, 64-बिट सिस्टम पर यह पहले से ही 8 बाइट्स है।
इसलिए, यदि x86 में एक खाली वर्ग केवल 12 बाइट्स है, तो x64 में 24 बाइट्स हैं।

सीएलआर वस्तु का आकार सीमा

यह आमतौर पर स्वीकार किया जाता है कि System.String का आकार केवल उपलब्ध सिस्टम मेमोरी द्वारा सीमित है।

हालाँकि, किसी भी प्रकार का कोई भी उदाहरण 2 Gb से अधिक मेमोरी पर कब्जा नहीं कर सकता है। और यह सीमा x86 और x64 दोनों प्रणालियों पर लागू होती है।

तो, सूची, हालांकि इसमें एक LongCount () विधि है, इसका मतलब 2 ^ 64 वस्तुओं की व्यवस्था करने की क्षमता नहीं है। इस उद्देश्य के लिए डिज़ाइन किए गए BigArray वर्ग का उपयोग करने के लिए समाधान हो सकता है।

अंतभाषण

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

अधिकांश भाग के लिए, वस्तुओं के आकार का सवाल, उनकी स्मृति में संरेखण तभी आता है जब एक मजबूत आवश्यकता होती है - संसाधनों के उपयोग के अनुकूलन की संभावना।

मुझे उम्मीद है कि लेख दिलचस्प और उपयोगी निकला। आपका ध्यान के लिए धन्यवाद!

सीएलआर वस्तुओं के आकार। सटीक परिभाषा