Effect of properties or get/set methods on object size

Question

In terms of object size, how do properties instead Get/Set methods affect object size if the exposed properties do not represent a state but simply delegate its getter and setter calls to another entity?

For example, consider the following classes:

public class Person
{
   Address _address = new Address();

   public string AddressName
   {
      get{ return _address.Name; }
      set { _address.Name = value; }
   }

   public string GetAddressName(){ return _address.Name; }
   public void SetAddressName(string name){ _address.Name = name; }

}

public Address
{
    public string Name { get; set; }
}

I am guessing that when a new Person is created, the CLR will take into consideration the potential size of AddressName property when determining how much memory to allocate. However, if all I exposed was the Get/Set AddressName methods, there will be no additional memory allocated to cater for an AddressName property. So, to conserve memory footprint, it is better in this case to use Get/Set methods. However, this will not make a difference with the Name property of the Address class as state is being preserved. Is this assumption correct?

`when a new Person is created, the CLR will take into consideration the potential size of AddressName` it will not, it will allocate enough space to store a reference to a string. — Ilya Ivanov, Feb 22 '13 at 13:48
Is this moreso out of curiosity? If this is meant to be practical, I wouldn't worry about the couple differences in the size of the generated IL (if there's any difference at all). — hometoast, Feb 22 '13 at 13:49
@IlyaIvanov, this is curiosity but also I am trying to take ever bit of performance considerations for this project. — Klaus Nji, Feb 22 '13 at 13:51
Agreed, I was wrong. I've looked at property `public string AddressName` and automatically thought about `string` being a type of a backing field. Thanks for correction — Ilya Ivanov, Feb 22 '13 at 13:52
See the excellent book **CLR Via C#** by Jeffrey Richter for the full details. Every C# programmer should read it. :) — Matthew Watson, Feb 22 '13 at 13:54

score 15 · Accepted Answer · edited May 09 '17 at 10:19

The size of an individual object is not affected by the number of properties, methods, events etc. It affects the size of the type metadata, and the JITted code - but not the per-object size. That's only affected by instance fields.

I am guessing that when a new Person is created, the CLR will take into consideration the potential size of AddressName property when determining how much memory to allocate.

No. It only looks at your fields. You have a single field (_address) so that plus the normal object overhead are all the memory required for a single instance.

score 6 · Answer 2 · answered Feb 22 '13 at 14:55

As Jon already answered, the size of an object instance is determined only by its instance fields. However, let me go into a little bit more detail.

An object instance is at the very least as big as the sum of the sizes of its fields. Depending on field alignment constraints and the way the CLR (Common Language Runtime) layouts the fields, some padding bytes may need to be taken into account. For reference types, an instance has two additional hidden fields: the sync block index and the type reference. Both are native integers. On the heap, instances have a minimum size of 12 bytes (regardless of how much space they actually need).

Take for example the following class:

class X
{
    byte value1;
    string value2;
    int value3;
    long value4;
}

On a 32-bit system, an instance of X may require 28 bytes:

2 times four bytes for the sync block index and type reference,
one byte for byte,
three padding bytes, to align the next field,
four bytes for the object reference string,
another four bytes for int
and eight bytes for long,

As you can see, the getters and setters, methods and constructors do not take up space in each object instance. Instead, there is a separate object (which you know as Type) that maintains a list of methods (getters, setters and constructors are also methods) and contains the static fields of the type. You can create as many object instances of a type as you want, but there will only be one Type object for any given type instance.

Effect of properties or get/set methods on object size

2 Answers2

Linked