What happens when assigning a new structure to an array in C #?

Question

Let's say I have a C # structure:

struct Foo{ int mA; public int A {get {return mA;}} int mB; public int B {get {return mB;}} public Foo(int a, int b) { mA = a; mB = b; } } 

And then I create and Foo's arrays:

 Foo[] foos = new Foo[10]; 

What happens when I do this?

 foos[1] = new Foo(20, 10); 

If Foo was a class, Foo [] would hold the pointer to the Foo object on the heap, and that pointer would be changed to a new Foo object (old for disposal).

But since structs are value types, does the new Foo (20, 10) just physically overwrite the same memory cell that foos [1] previously held?

Answer 1

In practice, the memory associated with the corresponding slot in the array is filled with values. Given your code, a small example shows what happens. Please see comments on the line. This is for the release build.

 static void Main(string[] args) { Foo[] foos = new Foo[10]; foos[1] = new Foo(127, 255); Console.ReadLine(); } 

The above JIT code is compiled as follows

 // Method setup 00280050 55 push ebp 00280051 8bec mov ebp,esp 00280053 56 push esi // Create instance of Foo[] 00280054 b98a141d00 mov ecx,1D148Ah 00280059 ba0a000000 mov edx,0Ah 0028005e e8b121f4ff call CORINFO_HELP_NEWARR_1_VC (001c2214) 00280063 8bd0 mov edx,eax // Array range check 00280065 837a0401 cmp dword ptr [edx+4],1 00280069 7624 jbe // Assign foos[1] = new Foo(127, 255) 0028006b 8d4210 lea eax,[edx+10h] <-- load location of foos[1] in eax 0028006e ba7f000000 mov edx,7Fh <-- load 127 in edx 00280073 beff000000 mov esi,0FFh <-- load 255 in esi 00280078 8910 mov dword ptr [eax],edx <-- move the value 127 to foos[1] 0028007a 897004 mov dword ptr [eax+4],esi <-- move the value 255 to foos[1] + offset // This is just for the Console.ReadLine() part + rest of Main 0028007d e8d2436305 call mscorlib_ni!System.Console.get_In() (058b4454) 00280082 8bc8 mov ecx,eax 00280084 8b01 mov eax,dword ptr [ecx] 00280086 8b402c mov eax,dword ptr [eax+2Ch] 00280089 ff501c call dword ptr [eax+1Ch] // Epilog 0028008c 5e pop esi 0028008d 5d pop ebp 0028008e c3 ret //Exception handling 0028008f e8f05e7f70 call clr!JIT_RngChkFail (70a75f84) 00280094 cc int 3 

In short, the code loads the constants in the registers, and then copies the values ​​of these registers into the memory associated with the corresponding part of the array instance.

Answer 2

foos[1] will contain a bit-muddy copy of new Foo(20, 10); .

Answer 3

Creating a struct array creates an instance of the default value in each slot. In C #, calling new in a structure in C # creates a new temporary instance (most likely on the stack) and assigning one structure to another, always mutates the last instance, overwriting all the fields of the latter with the contents of the corresponding fields in the former. Thus, the statement foos[1] = new Foo(20,10); creates a new temporary instance of Foo with default values, passes this instance to the parameterized constructor, copies all the fields of this temporary instance to the instance stored in slot 1 of the array, and then discards the temporary instance.

By the way, the behavior of the corresponding operator in vb.net is slightly different. The expression foos(1) = New Foo(20,10) will reset all foos(1) fields to their default values, and then pass foos(1) to the parameterized constructor. This difference can be significant if any code tries to access foos(1) while the constructor is running.