Getting the size of a field in bytes with C#

by

You can’t, basically. It will depend on padding, which may well be based on the CLR version you’re using and the processor etc. It’s easier to work out the total size of an object, assuming it has no references to other objects: create a big array, use GC.GetTotalMemory for a base point, fill the array with references to new instances of your type, and then call GetTotalMemory again. Take one value away from the other, and divide by the number of instances. You should probably create a single instance beforehand to make sure that no new JITted code contributes to the number. Yes, it’s as hacky as it sounds – but I’ve used it to good effect before now.

Just yesterday I was thinking it would be a good idea to write a little helper class for this. Let me know if you’d be interested.

EDIT: There are two other suggestions, and I’d like to address them both.

Firstly, the sizeof operator: this only shows how much space the type takes up in the abstract, with no padding applied round it. (It includes padding within a structure, but not padding applied to a variable of that type within another type.)

Next, Marshal.SizeOf: this only shows the unmanaged size after marshalling, not the actual size in memory. As the documentation explicitly states:

The size returned is the actually the
size of the unmanaged type. The
unmanaged and managed sizes of an
object can differ. For character
types, the size is affected by the
CharSet value applied to that class.

And again, padding can make a difference.

Just to clarify what I mean about padding being relevant, consider these two classes:

class FourBytes { byte a, b, c, d; }
class FiveBytes { byte a, b, c, d, e; }

On my x86 box, an instance of FourBytes takes 12 bytes (including overhead). An instance of FiveBytes takes 16 bytes. The only difference is the “e” variable – so does that take 4 bytes? Well, sort of… and sort of not. Fairly obviously, you could remove any single variable from FiveBytes to get the size back down to 12 bytes, but that doesn’t mean that each of the variables takes up 4 bytes (think about removing all of them!). The cost of a single variable just isn’t a concept which makes a lot of sense here.

More Related Contents:

  1. How do I get the path of the assembly the code is in?
  2. Set object property using reflection
  3. How can I evaluate C# code dynamically?
  4. How to Load an Assembly to AppDomain with all references recursively?
  5. Casting a variable using a Type variable
  6. How do I instantiate a class given its string name?
  7. Get all derived types of a type
  8. Using C# reflection to call a constructor
  9. How To Test if Type is Primitive
  10. Retrieving the calling method name from within a method [duplicate]
  11. How can I create an instance of an arbitrary Array type at runtime?
  12. Using IsAssignableFrom with ‘open’ generic types
  13. c# Creating an unknown generic type at runtime
  14. Discovering derived types using reflection
  15. How do I create a generic class from a string in C#? [duplicate]
  16. Get all types implementing specific open generic type
  17. Determine if a type is static
  18. Dynamic table name in linq [duplicate]
  19. How can you loop over the properties of a class?
  20. GetEntryAssembly for web applications
  21. Why is TargetInvocationException treated as uncaught by the IDE?
  22. Finding all Namespaces in an assembly using Reflection (DotNET)
  23. Get all properties which marked certain attribute
  24. Using GetProperties() with BindingFlags.DeclaredOnly in .NET Reflection
  25. Comparing Object properties using reflection
  26. How can I get the values of the parameters of a calling method?
  27. How to set value of property where there is no setter
  28. using type returned by Type.GetType() in c#
  29. Reflecting a private field from a base class
  30. Two Types not equal that should be

Leave a Comment