C# struct 或 struct[] 作为 memory 中连续结构的成员

Question

I am trying to understand how having a struct as a member of a struct would be stored in memory. From what I understand, if we had a simple struct in memory, for example

struct Simple {
  int x;
  bool y;
}

then in if we initialized Simple s = new Simple() in memory we would see something contiguous like

s(0x01) --> 0x01(x - 32 bits data, y - 32 bits data) 

so if we called sx then we would need to fetch s into the cpu and then have access to both x and y for operations since they are contiguous.

Now if we had an array of structs as a member

struct Simple {
  int x;
  Other[] otherArray;

  Simple(int input, Other[] otherInput)
  {
    x = input;
    otherArray = otherInput;
  }
}

struct Other {
  bool y;
}

if we did Simple s = new Simple() then in memory we would have

s(0x01) --> 0x01(x - 32 bits, otherArray - 64 bit reference type) 

s.otherArray[0] would need to be fetched separately wherever it is stored in memory. This is because the actual values within otherArray are not contiguously stored with x but the reference to the data is contiguous after x . If otherArray is initialized as Simple s = new Simple(1, new Simple[1]) , would otherArray data be stored contiguously after x or is otherArray always going to be a reference type either way (whether it's initialized in the struct constructor or not)?

Finally, if we have a struct as a member of a struct

struct Simple {
  int x;
  Other other;
}

this is where it is unclear for me. Is Simple s = new Simple() now stored as

s(0x01) --> 0x01(x - 32 bits data, other - 32 bits data of y as bool)

or is it

s(0x01) --> 0x01(x - 32 bits, other - some reference to the data containing y as bool)

In other words, is a struct as a member of struct stored contiguously with the struct or is it simply stored as some sort of address to the actual data of the other struct?

I would also appreciate any correction to my logic or further knowledge on how different types are stored in memory within struct as I am trying to generally understand how C# stores data in memory, thank you

Answer 1

would otherArray data be stored contiguously after x or is otherArray always going to be a reference type either way

otherArray is always going to be a reference to an array object, even if it only has one element. The struct layout is a property of the struct type, not a property of particular struct values.

is a struct as a member of struct stored contiguously with the struct or is it simply stored as some sort of address to the actual data of the other struct?

Structs are value types, so there is no "some sort of address to the actual data of the other struct". That's what reference types would do. It's not contiguous necessarily, (but it is contiguous in the case of Other and Simple ) - it will follow the default alignment rules if you don't specify an explicit Pack or LayoutKind . See here for more info.

Let's consider:

struct Simple
{
    public int x;
    public Other other;
}

struct Other
{
    public int y;
}

and the value:

var s = new Simple();
s.x = unchecked((int)0xabcdefab);
s.other.y = 0x12345678;

You'd expect the size of s be 8 bytes, and its value will contain the numbers 0xabcdefab and 0x12345678 :

// prints 8
Console.WriteLine(sizeof(Simple));
// in an unsafe block, prints 12345678ABCDEFAB
Console.WriteLine(Marshal.ReadInt64(new IntPtr(&s)).ToString("X"));

You can try adding more fields to Other , and see that sizeof(Simple) increases

Compare this to a reference type:

struct Simple
{
    public int x;
    public OtherRef other;
}

class OtherRef
{
    public int y;
}

You can't use & to get the address now, so here's a sharplab link to show that the other field is indeed an address, rather than the value you set it.