Question

In the .NET struct design guidelines, it gives the maximum sensible size of a struct as 16 bytes. How do you determine how large your struct is, and is it affected by the architecture your program is running on? Is this value 32-bit only, or for both archs?

Answer 1

Yes, the size of a struct is affected by the architecture. C# structs in 32bit are aligned at 4 byte boundaries, and in 64bit they are 8 byte aligned.

Example:

struct Foo
{
   int bar;
}

Instances of this struct will take up 4 bytes in 32bit processes, and 8 bytes in 64bit processes, even though the “int bar” takes just 4 bytes on both 32bit and 64bit processes.

Update:

I did some testing with this. I wrote this code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication3
{
    struct Bar
    {
        int a;
    }

    struct Foo
    {
        Uri uri;
        int a;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Foo[] foo;
            long fooBefore = System.GC.GetTotalMemory(true);
            foo = new Foo[10];
            long fooAfter = System.GC.GetTotalMemory(true);

            Bar[] bar;
            long barBefore = System.GC.GetTotalMemory(true);
            bar = new Bar[10];
            long barAfter = System.GC.GetTotalMemory(true);

            Foo aFoo = new Foo();
            Bar aBar = new Bar();

            System.Console.Out.WriteLine(String.Format("[Foo] Size of array of 10: {0}, Marshal size of one: {1}", fooAfter - fooBefore, System.Runtime.InteropServices.Marshal.SizeOf(aFoo)));
            System.Console.Out.WriteLine(String.Format("[Bar] Size of array of 10: {0}, Marshal size of one: {1}", barAfter - barBefore, System.Runtime.InteropServices.Marshal.SizeOf(aBar)));
            System.Console.ReadKey();
        }
    }
}

As a 64bit process, I get this output:

[Foo] Size of array of 10: 208, Marshal size of one: 16
[Bar] Size of array of 10: 88, Marshal size of one: 4

As a 32bit process, I get this output:

[Foo] Size of array of 10: 92, Marshal size of one: 8
[Bar] Size of array of 10: 64, Marshal size of one: 4

Observations:

• The simple struct, Bar, seems to take 4 bytes on both 32bit and 64bit processes
• The other struct, Foo, seems to take 8 bytes on 32bit (4 bytes for the int, and 4 bytes for the reference to the Uri), but 16 bytes on 64bit (4 bytes for the int, 8 bytes for the reference to the Uri, and I think 4 bytes for alignment)