Object Size

Smart Lucky

Hi

Can any one help me when i declare the object type variable how much space or memory will occupy it.....?

and what is difference b/w Object and object in .net

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes15y ago
All reference type objects are stored on the heap and the memory allocated is equal to the sum of the bytes needed for each of their instance fields plus overhead of 8 bytes (16 bytes on a 64-bit system).

However, for efficiency, the fields are normally aligned on 4 (or 8) byte boundaries - consistent with a 32-bit or 64-bit CPU - and their order may also be rearranged by the CLR. This may mean that the memory needed for the fields is more than you would otherwise expect.

The overhead contains a pointer to the object's 'type object' (every type is represented by a unique object of type System.Type) plus a 'sync block' index which is used when the object is the subject of a 'lock' statement (or Monitor.Enter) in a multi-threading scenario.

As far as the System.Object type is concerned (for which C#'s 'object' keyword is just an alias), it has no fields and you'd therefore expect an object of that type to just contain overead. However, for technical reasons, it is necessary to be able to point to the first byte of an object's fields and the CLR therefore needs to allocate a single byte for objects which have no fields, making a total of 9 on a 32-bit system or 17 on a 64-bit system. In practice, because of alignment, the next 3 (or 7 bytes) won't be used by the next object to be allocated so effectively the memory allocation is 12 (or 16) bytes.
0
Dorababu Meka15y ago
The size of an actual object doesn't include the size of any objects it references.
The only things which are likely to end up on the large object heap are arrays and strings - other objects tends to be relatively small in themselves. Even an object with (say) 10 reference type variables (4 bytes each on x86) and 10 GUIDs (16 bytes each) is only going to take up about 208 bytes (there's a bit of overhead for the type reference and sync block).
Likewise when thinking about the size of an array, don't forget that if the element type is a reference type, then it's only the size of the references that count for the array itself. In other words, even if you've got an array with 20,000 elements, the size of the array object itself will only be just over 80K (on x86) even if it references a lot more data

No difference

C# provides synonyms for the primitives defined by the CLR.
System.String -> string,
System.Int64 -> long,
System.Object -> object, like wise
0