blocks|key|1440383|text|ANTS+memory+profiler会准确地告诉你为每个对象/方法等分配了多少。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1440384|entityMap|0|LINK|mutability|MUTABLE|url|http://www.red-gate.com/products/ants_memory_profiler/index.htm^0|0|K|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

The <a href="http://www.red-gate.com/products/ants_memory_profiler/index.htm" rel="noreferrer">ANTS memory profiler</a> will tell you exactly how much is allocated for each object/method/etc.

blocks|key|1440405|text|你可以使用一个内存分析器，比如|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1440406|.NET内存分析器(http://memprofiler.com/)|offset|length|1440407|或|1440408|CLR分析器(免费)+(http://clrprofiler.codeplex.com/)|1440409|entityMap|0|LINK|mutability|MUTABLE|url|http://memprofiler.com/|1|http://clrprofiler.codeplex.com/^0|0|A|N|0|0|0|C|W|1|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@]|9|@$D|V|E|W|1|X]]|A|$]]|$1|F|3|G|5|6|7|Y|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|J|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|Q]]|R|$5|M|N|O|A|$P|S]]]]

You could use a memory profiler like

.NET Memory Profiler (<a href="http://memprofiler.com/" rel="noreferrer">http://memprofiler.com/</a>)

or

CLR Profiler (free) (<a href="http://clrprofiler.codeplex.com/" rel="noreferrer">http://clrprofiler.codeplex.com/</a>)

blocks|key|1441130|text|每个“类”都需要足够的内存来容纳运行时调用的所有成员的所有jit编译代码(尽管如果您很长时间没有调用一个方法，CLR可以释放该内存并在您再次调用它时重新对其进行jit...加上足够的内存来保存类中声明的所有静态变量...但是这个内存对于每个类只分配一次，不管你创建了多少个类的实例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1441131|对于您创建的类的每个实例(并且尚未被垃圾收集)，您可以通过将每个基于实例的声明变量的内存使用量相加来近似计算内存占用...(字段)|1441132|引用变量(引用到其他对象)需要4或8个字节(32/64位操作系统?)int16、Int32、Int64分别占用2、4或8个字节...|1441133|字符串变量为一些元数据元素占用额外的存储空间(加上地址指针的大小)|1441134|此外，对象中的每个引用变量也可以被认为“间接”包括它所指向的对象在堆上占用的内存，尽管您可能希望将该内存计算为属于该对象而不是引用它的变量……|1441135|等等等等。|1441136|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|P|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

Each "class" requires enough memory to hold all of it's jit-compiled code for all it's members that have been called by the runtime, (although if you don;t call a method for quite some time, the CLR can release that memory and re-jit it again if you call it again... plus enough memory to hold all static variables declared in the class... but this memory is allocated only once per class, no matter how many instances of the class you create. 

For each instance of the class that you create, (and has not been Garbage collected) you can approximate the memory footprint by adding up the memory usage by each instance-based declared variable... (field) 

reference variables (refs to other objects) take 4 or 8 bytes (32/64 bit OS ?)
int16, Int32, Int64 take 2,4, or 8 bytes, respectively... 

string variable takes extra storage for some meta data elements, (plus the size of the address pointer) 

In addition, each reference variable in an object could also be considered to "indirectly" include the memory taken up on the heap by the object it points to, although you would probably want to count that memory as belonging to that object not the variable that references it... 

etc. etc.

blocks|key|1655808|text|Here's+a+related+post，我们讨论了如何确定引用类型的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1655809|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/26570/sizeof-equivalent-for-reference-types^0|0|L|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

<a href="https://stackoverflow.com/questions/26570/sizeof-equivalent-for-reference-types">Here's a related post</a> where we discussed determining the size of reference types.

blocks|key|1441165|text|要对应用程序中的内存分配有一个大致的了解，可以在WinDbg中使用以下sos命令|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1441166|!dumpheap+-stat|code-block|syntax|javascript|1441167|请注意，!dumpheap仅提供对象类型本身的字节，不包括它可能引用的任何其他对象类型的字节。|1441168|如果想要查看特定对象类型的总持有字节数(对象引用的所有对象的所有字节之和)，请使用dot+Trace+-+http://www.jetbrains.com/profiler/之类的内存分析器|offset|length|1441169|entityMap|0|LINK|mutability|MUTABLE|url|http://www.jetbrains.com/profiler/^0|0|0|0|1H|Y|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|X|8|@]|9|@$K|Y|L|Z|1|10]]|A|$]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

To get a general sense for the memory allocation in your application, use the following sos command in WinDbg

<pre><code>!dumpheap -stat
</code></pre>

Note that !dumpheap only gives you the bytes of the object type itself, and doesn't include the bytes of any other object types that it might reference.

If you want to see the total held bytes (sum all the bytes of all objects referenced by your object) of a specific object type, use a memory profiler like dot Trace - <a href="http://www.jetbrains.com/profiler/" rel="noreferrer">http://www.jetbrains.com/profiler/</a>

blocks|key|1441192|text|一种粗略的方法可能是这样--如果你想知道一个特定对象发生了什么|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1441193|//+Measure+starting+point+memory+use
GC_MemoryStart+=+System.GC.GetTotalMemory(true);

//+Allocate+a+new+byte+array+of+20000+elements+(about+20000+bytes)
MyByteArray+=+new+byte[20000];

//+Obtain+measurements+after+creating+the+new+byte[]
GC_MemoryEnd+=+System.GC.GetTotalMemory(true);

//+Ensure+that+the+Array+stays+in+memory+and+doesn't+get+optimized+away
GC.KeepAlive(MyByteArray);|code-block|syntax|javascript|1441194|可以像下面这样获得整个过程的内容|1441195|long+Process_MemoryStart+=+0;
Process+MyProcess+=+System.Diagnostics.Process.GetCurrentProcess();
Process_MemoryStart+=+MyProcess.PrivateMemorySize64;|1441196|希望这能有所帮助;)|1441197|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

A coarse way could be this in-case you wanna know whats happening with a particular object

<pre><code>// Measure starting point memory use
GC_MemoryStart = System.GC.GetTotalMemory(true);

// Allocate a new byte array of 20000 elements (about 20000 bytes)
MyByteArray = new byte[20000];

// Obtain measurements after creating the new byte[]
GC_MemoryEnd = System.GC.GetTotalMemory(true);

// Ensure that the Array stays in memory and doesn't get optimized away
GC.KeepAlive(MyByteArray);
</code></pre>

process wide stuff could be obtained perhaps like this

<pre><code>long Process_MemoryStart = 0;
Process MyProcess = System.Diagnostics.Process.GetCurrentProcess();
Process_MemoryStart = MyProcess.PrivateMemorySize64;
</code></pre>

hope this helps ;)

blocks|key|1441226|text|如果你可以-序列化它！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1441227|Dim+myObjectSize+As+Long

Dim+ms+As+New+IO.MemoryStream
Dim+bf+As+New+Runtime.Serialization.Formatters.Binary.BinaryFormatter()
bf.Serialize(ms,+myObject)
myObjectSize+=+ms.Position|code-block|syntax|javascript|1441228|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you can - Serialize it!

<pre><code>Dim myObjectSize As Long

Dim ms As New IO.MemoryStream
Dim bf As New Runtime.Serialization.Formatters.Binary.BinaryFormatter()
bf.Serialize(ms, myObject)
myObjectSize = ms.Position
</code></pre>

blocks|key|1441269|text|对于任何潜伏在周围寻找答案的Unity+Dev，这里有一个方法可以比较@varun的答案启发下的两个不同的类内存分配：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1441270|void+Start()
++++{
++++++++var+totalMemory+=+System.GC.GetTotalMemory(false);
++++++++
++++++++var+class1+=+new+Class1[100000];
++++++++System.GC.KeepAlive(class1);
++++++++for+(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++{
++++++++++++class1[i]+=+new+Class1();
++++++++}

++++++++var+newTotalMemory+=+System.GC.GetTotalMemory(false);
++++++++Debug.Log($"Class1:+{newTotalMemory}+-+{totalMemory}+=+{newTotalMemory+-+totalMemory}");

++++++++var+class2+=+new+Class2[100000];
++++++++System.GC.KeepAlive(class2);
++++++++for+(int+i+=+0;+i+<+100000;+i%2B%2B)
++++++++{
++++++++++++class2[i]+=+new+Class2(10,+10);
++++++++}

++++++++var+newTotalMemory2+=+System.GC.GetTotalMemory(false);
++++++++Debug.Log($"Class2:+{newTotalMemory2}+-+{newTotalMemory}+=+{newTotalMemory2+-+newTotalMemory}");
++++}|code-block|syntax|javascript|1441271|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For any Unity Dev lurking around for an answer, here's a way to compare two different class memory allocations inspired by @varun's answer:
<pre><code>void Start()
 {
 var totalMemory = System.GC.GetTotalMemory(false);
 
 var class1 = new Class1[100000];
 System.GC.KeepAlive(class1);
 for (int i = 0; i &lt; 100000; i++)
 {
 class1[i] = new Class1();
 }

 var newTotalMemory = System.GC.GetTotalMemory(false);
 Debug.Log($&quot;Class1: {newTotalMemory} - {totalMemory} = {newTotalMemory - totalMemory}&quot;);

 var class2 = new Class2[100000];
 System.GC.KeepAlive(class2);
 for (int i = 0; i &lt; 100000; i++)
 {
 class2[i] = new Class2(10, 10);
 }

 var newTotalMemory2 = System.GC.GetTotalMemory(false);
 Debug.Log($&quot;Class2: {newTotalMemory2} - {newTotalMemory} = {newTotalMemory2 - newTotalMemory}&quot;);
 }
</code></pre>

I'm developing an application which currently have hundreds of objects created. 

Is it possible to determine (or approximate) the memory allocated by an object (class instance)?

How much memory does a C#/.NET object use?

我正在开发一个应用程序，它目前已经创建了数百个对象。可以确定(或近似)对象(类实例)分配的内存吗？

问一个C#/.NET对象使用多少内存？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个C#/.NET对象使用多少内存？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个C#/.NET对象使用多少内存？
EN