C # में बाइट्स में ऑब्जेक्ट इंस्टेंस का आकार ज्ञात करें

Question

किसी भी मनमाने उदाहरण के लिए (विभिन्न वस्तुओं, रचनाओं, एकल वस्तुओं आदि का संग्रह)

मैं बाइट्स में इसका आकार कैसे निर्धारित कर सकता हूं?

(मुझे वर्तमान में विभिन्न वस्तुओं का एक संग्रह मिला है और मैं इसके समग्र आकार को निर्धारित करने की कोशिश कर रहा हूं)

संपादित करें: क्या किसी ने ऑब्जेक्ट के लिए एक विस्तार विधि लिखी है जो ऐसा कर सकती है? यह बहुत साफ imo होगा।

Comments

मेमोरी में ऑब्जेक्ट का आकार कैसे प्राप्त करें?

— जोएर्ड

सी # के साथ बाइट्स में एक क्षेत्र का आकार प्राप्त करने

— AxelEckenberger

Answer 1

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

आप इस लेख में सीएलआर इंटर्नल एमएसडीएन मैगज़ीन अंक 2005 मई - ड्रिल इनटू .NET फ्रेमवर्क इंटर्नल पर यह देखने के लिए उपयोग कर सकते हैं कि सीएलआर कैसे रनटाइम ऑब्जेक्ट्स बनाता है - पिछली बार मैंने जाँच की थी, यह अभी भी लागू था। यहां बताया गया है कि यह कैसे किया जाता है (यह TypeHandleटाइप के माध्यम से आंतरिक "बेसिक इंस्टेंस साइज" फ़ील्ड को पुनः प्राप्त करता है )।

object obj = new List<int>(); // whatever you want to get the size of
RuntimeTypeHandle th = obj.GetType().TypeHandle;
int size = *(*(int**)&th + 1);
Console.WriteLine(size);

यह 3.5 SP1 32-बिट पर काम करता है। मुझे यकीन नहीं है कि यदि क्षेत्र का आकार 64-बिट पर समान है - तो आपको प्रकार और / या ऑफ़सेट को समायोजित करना पड़ सकता है यदि वे नहीं हैं।

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

Comments

नहीं, ऐसा करने का कोई "उचित" तरीका नहीं है, क्योंकि यह कुछ ऐसा नहीं है जो एक अच्छी तरह से व्यवहार किया गया .NET अनुप्रयोग पहले स्थान पर संबंधित होना चाहिए। सीएलआर के एक विशेष कार्यान्वयन के आंतरिक डेटा संरचनाओं के साथ ऊपर दिए गए मूक सीधे (उदाहरण के लिए, .NET के अगले संस्करण में आसानी से बदल सकते हैं)।

— पावेल मिनेव

क्या यह C # में काम करने वाला है या केवल c ++ प्रबंधित है? यह C # में अब तक खुश नहीं है कि मैंने इसे आजमाया है:Cannot take the address of, get the size of, or declare a pointer to a managed type ('System.RuntimeTypeHandle')

— Maslow

इस के .NET 4 संस्करण को भी असुरक्षित कोड की आवश्यकता नहीं है: Marshal.ReadInt32(type.TypeHandle.Value, 4)x86 और x64 के लिए काम करता है। मैंने केवल संरचना और वर्ग प्रकारों का परीक्षण किया। ध्यान रखें कि यह मूल्य प्रकारों के लिए बॉक्सेड आकार देता है । @ पावेल शायद आप अपना उत्तर अपडेट कर सकते हैं।

— jnm2

@ sab669 अच्छी तरह से, उसके उदाहरण के typeसाथ बदलें obj.GetType()। इससे कोई फर्क नहीं पड़ता कि आप किस ढांचे का उपयोग कर रहे हैं, केवल क्या सीएलआर (v2 या v4 या CoreCLR)। मैंने CoreCLR पर इसकी कोशिश नहीं की है।

— jnm2

@SamGoldberg मैन्युअल रूप से यह गणना करना एक मिलियन एज मामलों के साथ बहुत काम है। Sizeof आपको ऑब्जेक्ट का स्थिर आकार बताता है, न कि वस्तुओं के रनटाइम ग्राफ की मेमोरी खपत। VS2017 की मेमोरी और सीपीयू प्रोफाइलिंग बहुत अच्छी है, जैसा कि रेस्परर और अन्य उपकरण हैं, और यही मैं मापने के लिए उपयोग करता हूं।

— jnm2

Answer 2

यदि आप अनुक्रमिक वस्तुओं के साथ काम कर रहे हैं, तो आप इसे द्विआधारी धारावाहिक (लेकिन विस्मृति के लिए आउटपुट को रूट करना) के साथ क्रमबद्ध करने के बहाने आकार का अनुमान लगाने में सक्षम हो सकते हैं।

class Program
{
    static void Main(string[] args)
    {
        A parent;
        parent = new A(1, "Mike");
        parent.AddChild("Greg");
        parent.AddChild("Peter");
        parent.AddChild("Bobby");

        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf =
           new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
        SerializationSizer ss = new SerializationSizer();
        bf.Serialize(ss, parent);
        Console.WriteLine("Size of serialized object is {0}", ss.Length);
    }
}

[Serializable()]
class A
{
    int id;
    string name;
    List<B> children;
    public A(int id, string name)
    {
        this.id = id;
        this.name = name;
        children = new List<B>();
    }

    public B AddChild(string name)
    {
        B newItem = new B(this, name);
        children.Add(newItem);
        return newItem;
    }
}

[Serializable()]
class B
{
    A parent;
    string name;
    public B(A parent, string name)
    {
        this.parent = parent;
        this.name = name;
    }
}

class SerializationSizer : System.IO.Stream
{
    private int totalSize;
    public override void Write(byte[] buffer, int offset, int count)
    {
        this.totalSize += count;
    }

    public override bool CanRead
    {
        get { return false; }
    }

    public override bool CanSeek
    {
        get { return false; }
    }

    public override bool CanWrite
    {
        get { return true; }
    }

    public override void Flush()
    {
        // Nothing to do
    }

    public override long Length
    {
        get { return totalSize; }
    }

    public override long Position
    {
        get
        {
            throw new NotImplementedException();
        }
        set
        {
            throw new NotImplementedException();
        }
    }

    public override int Read(byte[] buffer, int offset, int count)
    {
        throw new NotImplementedException();
    }

    public override long Seek(long offset, System.IO.SeekOrigin origin)
    {
        throw new NotImplementedException();
    }

    public override void SetLength(long value)
    {
        throw new NotImplementedException();
    }
}

Comments

बेशक, यह आपको एक न्यूनतम आकार प्राप्त कर सकता है, लेकिन आपको स्मृति में आकार के बारे में कुछ नहीं बताता है।

— जॉन सॉन्डर्स

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

— जेनी

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

— जॉन साउंडर्स

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

— BlueMonkMN

मैं सहमत हूं - .NET ऑब्जेक्ट ग्राफ के आकार का बॉलपार्क अनुमान लगाना उपयोगी है।

— क्रेग शीयर

Answer 3

मानवरहित प्रकार उर्फ ​​मान प्रकारों के लिए, संरचनाएं:

        Marshal.SizeOf(object);

प्रबंधित वस्तुओं के लिए मुझे जो करीब मिला वह एक अनुमान है।

        long start_mem = GC.GetTotalMemory(true);

        aclass[] array = new aclass[1000000];
        for (int n = 0; n < 1000000; n++)
            array[n] = new aclass();

        double used_mem_median = (GC.GetTotalMemory(false) - start_mem)/1000000D;

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

इसके अलावा यह आपको स्मृति में वास्तविक आकार नहीं बताएगा और न ही मेमोरी संरेखण को ध्यान में रखेगा।

[संपादित करें] BiteConverter.GetBytes (प्रोप-वैल्यू) का उपयोग करके अपने वर्ग की हर संपत्ति पर पुनरावर्तक रूप से आपको बाइट्स में सामग्री मिलेगी, जो वर्ग या संदर्भों के वजन की गणना नहीं करता है, लेकिन वास्तविकता के बहुत करीब है। मैं डेटा के लिए एक बाइट ऐरे का उपयोग करने की सलाह दूंगा और एक मानवरहित प्रॉक्सी क्लास को पॉइंटर कास्टिंग का उपयोग करके मानों का उपयोग करने के लिए यदि आकार मायने रखता है, तो ध्यान दें कि गैर-संरेखित मेमोरी होगी ताकि पुराने कंप्यूटरों पर धीमी गति से हो, लेकिन MOD RAM रैम पर विशाल डेटासेट होने वाला है रैम से पढ़ने के लिए आकार कम से कम करने से असंबद्ध की तुलना में एक बड़ा प्रभाव होने वाला है।

Answer 4

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

इससे ऑब्जेक्ट आकार को उजागर करने के लिए एक विश्वसनीय, सामान्य एपीआई बनाना असंभव हो जाता है।

Comments

दिलचस्प। तो लोग अपनी वस्तुओं के आकार / वस्तुओं के संग्रह को गतिशील रूप से निर्धारित करने के लिए क्या करते हैं?

— जेनी

यह इस बात पर निर्भर करता है कि उन्हें इसके लिए क्या चाहिए। यदि P / Invoke (देशी कोड इंटरोप) के लिए, वे Marshal.SizeOf (टाइपोफ़ (T)) का उपयोग करते हैं। यदि मेमोरी प्रोफाइलिंग के लिए, वे एक अलग प्रोफाइल का उपयोग करते हैं जो जानकारी प्रदान करने के लिए निष्पादन वातावरण के साथ सहयोग करता है। यदि आप किसी सरणी में तत्व संरेखण में रुचि रखते हैं, तो आप डायनेमिकमैथोड में SizeOf IL opcode का उपयोग कर सकते हैं (मुझे नहीं लगता कि इसके लिए .NET फ्रेमवर्क में एक आसान तरीका है)।

— सैम हरवेल

Answer 5

कुछ अनुकूलन के साथ सुरक्षित समाधान CyberSaving / MemoryUsage कोड । कुछ मामला:

/* test nullable type */      
TestSize<int?>.SizeOf(null) //-> 4 B

/* test StringBuilder */    
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) sb.Append("わたしわたしわたしわ");
TestSize<StringBuilder>.SizeOf(sb ) //-> 3132 B

/* test Simple array */    
TestSize<int[]>.SizeOf(new int[100]); //-> 400 B

/* test Empty List<int>*/    
var list = new List<int>();  
TestSize<List<int>>.SizeOf(list); //-> 205 B

/* test List<int> with 100 items*/
for (int i = 0; i < 100; i++) list.Add(i);
TestSize<List<int>>.SizeOf(list); //-> 717 B

यह कक्षाओं के साथ भी काम करता है:

class twostring
{
    public string a { get; set; }
    public string b { get; set; }
}
TestSize<twostring>.SizeOf(new twostring() { a="0123456789", b="0123456789" } //-> 28 B

Comments

यही वह तरीका है जो मैं भी अपनाऊंगा। आप ग्राफ़ में पहले से सामना की गई वस्तुओं का एक सेट जोड़ सकते हैं) एक से बचने के लिए अनंत पुनरावृत्ति और बी) एक ही मेमोरी को दो बार जोड़ने से बचें।

— मफू

Answer 6

यह रनटाइम पर करना असंभव है।

हालांकि, विभिन्न मेमोरी प्रोफाइलर्स हैं जो ऑब्जेक्ट आकार को प्रदर्शित करते हैं।

संपादित करें : आप एक दूसरा कार्यक्रम लिख सकते हैं जो सीएलआर प्रोफाइलिंग एपीआई का उपयोग करते हुए पहले प्रोफाइल बनाता है और इसे रिमॉटिंग या कुछ के माध्यम से संचार करता है।

Comments

यदि रनटाइम पर ऐसा करना असंभव है, तो मेमोरी प्रोफाइलर्स जानकारी कैसे प्रदान कर रहे हैं?

— जेनी

प्रोफाइलिंग एपीआई का उपयोग करके। हालाँकि, कोई प्रोग्राम खुद को प्रोफाइल नहीं कर सकता

— SLaks

दिलचस्प। क्या होगा अगर मैं उन मामलों के साथ कोड सौदा करना चाहता हूं जब ऑब्जेक्ट बहुत अधिक मेमोरी का उपभोग कर रहे थे?

— जेनी

तब आप स्वयं-जागरूक सॉफ़्टवेयर के साथ काम कर रहे होंगे, और मुझे बहुत डर लगेगा। :-) गंभीरता से, "एकल जिम्मेदारी प्रिंसिपल" - प्रोग्राम को प्रोग्राम होने दें, कुछ अन्य कोड को बहुत अधिक मेमोरी लेने वाली वस्तुओं के लिए देखने दें।

— जॉन साउंडर्स

@ जानी: आप आकार के महत्व के बारे में भी धारणा बना रहे होंगे और यह प्रदर्शन से कैसे संबंधित होगा। मुझे लगता है कि आप ऐसा करने से पहले एक वास्तविक निम्न-स्तरीय सीएलआर प्रदर्शन विशेषज्ञ (जिस तरह की प्रोफाइल के बारे में पहले से ही जानते हैं) होना चाहते हैं। अन्यथा, आप अपने पहले के अनुभवों को ऐसी स्थिति में लागू कर सकते हैं जिसमें वे लागू नहीं होते हैं।

— जॉन सॉन्डर्स

Answer 7

सोन ऑफ स्ट्राइक का प्रयोग करें जिसमें एक कमांड हो ObjSize।

ध्यान दें कि खपत की गई वास्तविक मेमोरी हमेशा ObjSizeरिपोर्ट से बड़ी होती है, synkblkजो ऑब्जेक्ट डेटा से पहले सीधे रहती है।

दोनों के बारे में यहाँ पढ़ें MSDN मैगज़ीन अंक 2005 मई - ड्रिल इनटू फ्रेमवर्क इन्टर्नल्स यह देखने के लिए कि कैसे CLR रनटाइम ऑब्जेक्ट्स बनाता है ।

Answer 8

AFAIK, आप वास्तव में बाइट्स में प्रत्येक सदस्य के आकार की गहरी-गिनती के बिना नहीं कर सकते। लेकिन फिर, क्या किसी सदस्य का आकार (एक संग्रह के अंदर के तत्व की तरह) वस्तु के आकार की ओर गिना जाता है, या उस सदस्य का कोई संकेतक वस्तु के आकार की ओर गिनता है? इस पर निर्भर करता है कि आप इसे कैसे परिभाषित करते हैं।

मैं इस स्थिति में चला गया हूं, इससे पहले कि मैं अपने कैश में उन वस्तुओं को सीमित करना चाहता था जो वे खपत की गई मेमोरी के आधार पर करते थे।

खैर, अगर ऐसा करने के लिए कुछ चाल है, तो मुझे इसके बारे में जानकर खुशी होगी!

Answer 9

मूल्य प्रकारों के लिए, आप उपयोग कर सकते हैं Marshal.SizeOf। बेशक, यह अप्रबंधित स्मृति में संरचना को मार्शल करने के लिए आवश्यक बाइट्स की संख्या लौटाता है, जो जरूरी नहीं कि सीएलआर का उपयोग करता है।

Comments

भविष्य के रिलीज में SizeOf (ऑब्जेक्ट) अनुपलब्ध हो सकता है। इसके बजाय, SizeOf <T> () का उपयोग करें। अधिक जानकारी के लिए go.microsoft.com/fwlink/?LinkID=296514

— विनीगस

Answer 10

आप सभी सार्वजनिक सदस्य या संपत्ति की जानकारी (ऑब्जेक्ट के प्रकार को देखते हुए) इकट्ठा करने के लिए प्रतिबिंब का उपयोग कर सकते हैं। हालांकि, वस्तु पर डेटा के प्रत्येक व्यक्तिगत टुकड़े के माध्यम से चलने के बिना आकार का निर्धारण करने का कोई तरीका नहीं है।

Answer 11

किसी ऐसे समाधान की तलाश में जिसे [Serializable]कक्षाओं की आवश्यकता नहीं है और जहां सटीक विज्ञान के बजाय परिणाम एक अनुमान है। सबसे अच्छी विधि मुझे मिल सकती है जो UTF32 एन्कोडिंग का उपयोग करके एक मेमोरीस्ट्रीम में जसन क्रमांकन है।

private static long? GetSizeOfObjectInBytes(object item)
{
    if (item == null) return 0;
    try
    {
        // hackish solution to get an approximation of the size
        var jsonSerializerSettings = new JsonSerializerSettings
        {
            DateFormatHandling = DateFormatHandling.IsoDateFormat,
            DateTimeZoneHandling = DateTimeZoneHandling.Utc,
            MaxDepth = 10,
            ReferenceLoopHandling = ReferenceLoopHandling.Ignore
        };
        var formatter = new JsonMediaTypeFormatter { SerializerSettings = jsonSerializerSettings };
        using (var stream = new MemoryStream()) { 
            formatter.WriteToStream(item.GetType(), item, stream, Encoding.UTF32);
            return stream.Length / 4; // 32 bits per character = 4 bytes per character
        }
    }
    catch (Exception)
    {
        return null;
    }
}

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

ध्यान दें कि यह भी बहुत धीमा है।

Answer 12

पावेल और jnm2 से:

private int DumpApproximateObjectSize(object toWeight)
{
   return Marshal.ReadInt32(toWeight.GetType().TypeHandle.Value, 4);
}

एक ओर ध्यान दें क्योंकि यह केवल सन्निहित स्मृति वस्तुओं के साथ काम करता है

Answer 13

मैंने .NET में विभिन्न संग्रहों के लिए बेंचमार्क टेस्ट बनाया है: https://github.com/scholtz/TestDotNetCollectionsMemoryAllocation

परिणाम .NET कोर 2.2 के लिए निम्नानुसार हैं। 3 वस्तुओं के 1,000,000 के साथ आवंटित 3 गुण:

Testing with string: 1234567
Hashtable<TestObject>:                                     184 672 704 B
Hashtable<TestObjectRef>:                                  136 668 560 B
Dictionary<int, TestObject>:                               171 448 160 B
Dictionary<int, TestObjectRef>:                            123 445 472 B
ConcurrentDictionary<int, TestObject>:                     200 020 440 B
ConcurrentDictionary<int, TestObjectRef>:                  152 026 208 B
HashSet<TestObject>:                                       149 893 216 B
HashSet<TestObjectRef>:                                    101 894 384 B
ConcurrentBag<TestObject>:                                 112 783 256 B
ConcurrentBag<TestObjectRef>:                               64 777 632 B
Queue<TestObject>:                                         112 777 736 B
Queue<TestObjectRef>:                                       64 780 680 B
ConcurrentQueue<TestObject>:                               112 784 136 B
ConcurrentQueue<TestObjectRef>:                             64 783 536 B
ConcurrentStack<TestObject>:                               128 005 072 B
ConcurrentStack<TestObjectRef>:                             80 004 632 B

मेमोरी टेस्ट के लिए मुझे सबसे अच्छा इस्तेमाल किया गया

GC.GetAllocatedBytesForCurrentThread()

Answer 14

संरचना / मानों के सरणियों के लिए, मेरे पास अलग-अलग परिणाम हैं:

first = Marshal.UnsafeAddrOfPinnedArrayElement(array, 0).ToInt64();
second = Marshal.UnsafeAddrOfPinnedArrayElement(array, 1).ToInt64();
arrayElementSize = second - first;

(ओवरसाइम्प्लीफाइड उदाहरण)

जो भी दृष्टिकोण है, आपको वास्तव में यह समझने की आवश्यकता है कि कैसे .Net परिणामों की सही व्याख्या करने के लिए काम करता है। उदाहरण के लिए, लौटाया गया तत्व आकार "गठबंधन" तत्व आकार है, जिसमें कुछ पैडिंग है। ओवरहेड और इस प्रकार आकार एक प्रकार के उपयोग के आधार पर अलग-अलग होता है: जीसी हीप पर "बॉक्सिंग", ढेर पर, एक क्षेत्र के रूप में, एक सरणी तत्व के रूप में।

(मैं यह जानना चाहता था कि जेनरिक की "वैकल्पिक" तर्कों की नकल करने के लिए "डमी" खाली संरचनाओं (किसी भी क्षेत्र के बिना) का उपयोग करने का मेमोरी प्रभाव क्या होगा; खाली संरचना वाले विभिन्न लेआउट के साथ परीक्षण करना, मैं देख सकता हूं कि एक खाली संरचना का उपयोग करता है; कम से कम) 1 बाइट प्रति तत्व; मुझे अस्पष्ट रूप से यह याद है क्योंकि नेट प्रत्येक क्षेत्र के लिए एक अलग पते की आवश्यकता है, जो काम नहीं करेगा यदि कोई क्षेत्र वास्तव में खाली / 0-आकार का था)।

Answer 15

सबसे सरल तरीका है: int size = *((int*)type.TypeHandle.Value + 1)

मुझे पता है कि यह कार्यान्वयन विस्तार है, लेकिन जीसी इस पर निर्भर करता है और इसे दक्षता के लिए मेथेमेटिबल के शुरू होने के करीब होने की आवश्यकता है और साथ ही यह ध्यान रखना चाहिए कि जीसी कोड कॉम्प्लेक्स कोई भी नहीं है कि भविष्य में इसे बदलने की हिम्मत न हो। वास्तव में यह .net फ्रेमवर्क + .net कोर के हर छोटे / प्रमुख संस्करणों के लिए काम करता है। (वर्तमान में 1.0 के लिए परीक्षण करने में असमर्थ)
यदि आप अधिक विश्वसनीय तरीका चाहते हैं, तो एक डायनामिक असेंबली में एक संरचना [StructLayout(LayoutKind.Auto)]को उसी क्रम में समान फ़ील्ड के साथ उत्सर्जित करें, इसका आकार sizeof IL निर्देश के साथ लें। आप संरचना के भीतर एक स्थैतिक विधि का उत्सर्जन करना चाह सकते हैं जो केवल इस मान को लौटाता है। फिर ऑब्जेक्ट हेडर के लिए 2 * IntPtr.Size जोड़ें। यह आपको सटीक मूल्य देना चाहिए।
लेकिन अगर आपकी कक्षा दूसरी कक्षा से निकलती है, तो आपको बेस क्लास के प्रत्येक आकार को अलग-अलग खोजने और उन्हें जोड़ने की जरूरत है + 2 * Inptr.Size फिर से हेडर के लिए। आप BindingFlags.DeclaredOnlyध्वज के साथ फ़ील्ड प्राप्त करके ऐसा कर सकते हैं ।
Arrays और तार बस उस आकार को उसकी लंबाई * तत्व आकार जोड़ता है। एग्रीग्रेटगेट वस्तुओं के संचयी आकार के लिए आपको अधिक परिष्कृत समाधान को लागू करने की आवश्यकता होती है जिसमें हर क्षेत्र का दौरा करना और उसकी सामग्री का निरीक्षण करना शामिल है।