What is memory alignment and padding? How does the CLR lay out structs and classes in memory, and when would you control layout with StructLayout?

1. Alignment rules (64-bit)

Struct alignment = largest field alignment; struct size = padded to a multiple of that.

2. What an object looks like

          reference points here
                 |
                 v
[ object header (8) ][ MethodTable* (8) ][ fields ... (auto layout) ][pad]
  sync block index,     type info,          references grouped first
  hash code, lock bits  vtable, GC info     then 8, 4, 2, 1-byte fields

int[] array:  [header][MethodTable*][length (8 on 64-bit, incl. padding)][elements...]

3. Pack and Explicit

[StructLayout(LayoutKind.Sequential, Pack = 1)]   // no padding: matches a packed C struct
public struct PackedHeader { public byte Version; public uint Length; public ushort Flags; }   // 7 bytes

[StructLayout(LayoutKind.Explicit)]
public struct Int32Bytes                          // a union: same 4 bytes viewed two ways
{
    [FieldOffset(0)] public int Value;
    [FieldOffset(0)] public byte B0;
    [FieldOffset(1)] public byte B1;
    [FieldOffset(2)] public byte B2;
    [FieldOffset(3)] public byte B3;
}

Pack = 1 makes Length misaligned at offset 1, which is fine for marshalling but slower to access and not atomic.

4. Managed versus marshalled layout

With LibraryImport (source-generated interop), prefer blittable types (only primitives and blittable structs) so data passes without copying. DisableRuntimeMarshalling makes that explicit.

5. Aligned native memory

NativeMemory.AlignedAlloc(size, alignment) and NativeMemory.AlignedFree (.NET 6+) allocate memory aligned to, for example, 64 bytes for SIMD or cache-line-sized buffers.

6. Inspecting layout

• Unsafe.SizeOf<T>() and field offsets via a quick unsafe helper or ObjectLayoutInspector (a community NuGet package that prints field offsets and padding).
• Visual Studio's Memory window shows the bytes of an object in a debugging session.

7. Try it yourself

1. Declare Bad and Good from the answer and print Unsafe.SizeOf for each; then allocate 10 million of each in arrays and compare GC.GetTotalMemory.
2. Add a string field to Bad and check whether the size and order change.
3. Compare Unsafe.SizeOf<T>() and Marshal.SizeOf<T>() for a struct with a bool field.
4. Define an [InlineArray(8)] struct of int and use it as a fixed-size buffer with Span<int>.

namespace Alignment;

using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

public struct Bad  { public bool IsBid; public double Price; public int Size; public bool IsFirm; }
public struct Good { public double Price; public int Size; public bool IsBid; public bool IsFirm; }

[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PackedHeader { public byte Version; public uint Length; public ushort Flags; }

public struct WithBool { public bool Flag; public int Value; }

[InlineArray(8)]
public struct Buffer8 { private int _element0; }

public static class Program
{
    public static void Main()
    {
        Console.WriteLine($"Bad:          {Unsafe.SizeOf<Bad>()} bytes");          // 24
        Console.WriteLine($"Good:         {Unsafe.SizeOf<Good>()} bytes");         // 16
        Console.WriteLine($"PackedHeader: {Unsafe.SizeOf<PackedHeader>()} bytes");  // 7
        Console.WriteLine($"WithBool managed {Unsafe.SizeOf<WithBool>()}, marshalled {Marshal.SizeOf<WithBool>()}"); // 8 vs 8 (bool marshals as 4 bytes, then int)

        long before = GC.GetAllocatedBytesForCurrentThread();
        var bad = new Bad[1_000_000];
        long badBytes = GC.GetAllocatedBytesForCurrentThread() - before;

        before = GC.GetAllocatedBytesForCurrentThread();
        var good = new Good[1_000_000];
        long goodBytes = GC.GetAllocatedBytesForCurrentThread() - before;
        Console.WriteLine($"1M Bad: {badBytes / 1_000_000.0:F1} MB, 1M Good: {goodBytes / 1_000_000.0:F1} MB");

        var buffer = new Buffer8();
        Span<int> span = buffer;                 // InlineArray converts to Span<T>
        span.Fill(7);
        Console.WriteLine(span.Length);          // 8
        GC.KeepAlive(bad); GC.KeepAlive(good);
    }
}