C # Collection Initialization Syntax Avoid Default Initialization

Question

When you use the new C # collection initialization syntax:

string[] sarray = new[] { "A", "B", "C", "D" }; 

the compiler avoids initializing each slot in the array with a default value, or it is equivalent:

 string[] sarray = new string[4]; // all slots initialized to null sarray[0] = "A"; sarray[1] = "B"; sarray[2] = "C"; sarray[3] = "D"; 

Answer 1

The compiler still uses the newarr IL newarr , so the CLR will initialize the array.

Initializing the collection is just the magic of the compiler - the CLR knows nothing about it, so it will still assume that it needs to make a permission for eyesight.

However, it should be really, really fast - it's just clearing the memory. I doubt this is a significant overhead in many situations.

Answer 2

Quick test:

  string[] arr1 = { "A","B","C","D" }; arr1.GetHashCode(); string[] arr2 = new string[4]; arr2[0] = "A"; arr2[1] = "B"; arr2[2] = "C"; arr2[3] = "D"; arr2.GetHashCode(); 

leads to this IL (note that they are both identical)

  IL_0002: newarr [mscorlib]System.String IL_0007: stloc.2 IL_0008: ldloc.2 IL_0009: ldc.i4.0 IL_000a: ldstr "A" IL_000f: stelem.ref IL_0010: ldloc.2 IL_0011: ldc.i4.1 IL_0012: ldstr "B" IL_0017: stelem.ref IL_0018: ldloc.2 IL_0019: ldc.i4.2 IL_001a: ldstr "C" IL_001f: stelem.ref IL_0020: ldloc.2 IL_0021: ldc.i4.3 IL_0022: ldstr "D" IL_0027: stelem.ref IL_0028: ldloc.2 IL_0029: stloc.0 IL_002a: ldloc.0 IL_002b: callvirt instance int32 [mscorlib]System.Object::GetHashCode() IL_0030: pop IL_0031: ldc.i4.4 IL_0032: newarr [mscorlib]System.String IL_0037: stloc.1 IL_0038: ldloc.1 IL_0039: ldc.i4.0 IL_003a: ldstr "A" IL_003f: stelem.ref IL_0040: ldloc.1 IL_0041: ldc.i4.1 IL_0042: ldstr "B" IL_0047: stelem.ref IL_0048: ldloc.1 IL_0049: ldc.i4.2 IL_004a: ldstr "C" IL_004f: stelem.ref IL_0050: ldloc.1 IL_0051: ldc.i4.3 IL_0052: ldstr "D" IL_0057: stelem.ref IL_0058: ldloc.1 IL_0059: callvirt instance int32 [mscorlib]System.Object::GetHashCode() 

Answer 3

I tested a short test on an array instance using the syntax you are describing, and found that creating instances with values ​​other than the defaults decreased about 2.2 times longer than the instantaneous value with the defaults.

It takes about the same amount of time to switch and create instances with default values.

In fact, when I looked at decompilation, it seems that what happens is that the array is initialized and then filled with any values ​​that are not standard.

Creating instances with non-standard values:

  bool[] abPrimes = new[] { true, true }; 0000007e mov edx,2 00000083 mov ecx,79114A46h 00000088 call FD3006F0 0000008d mov dword ptr [ebp-64h],eax 00000090 mov eax,dword ptr [ebp-64h] 00000093 mov dword ptr [ebp-54h],eax 00000096 mov eax,dword ptr [ebp-54h] 00000099 cmp dword ptr [eax+4],0 0000009d ja 000000A4 0000009f call 76A9A8DC 000000a4 mov byte ptr [eax+8],1 000000a8 mov eax,dword ptr [ebp-54h] 000000ab cmp dword ptr [eax+4],1 000000af ja 000000B6 000000b1 call 76A9A8DC 000000b6 mov byte ptr [eax+9],1 000000ba mov eax,dword ptr [ebp-54h] 000000bd mov dword ptr [ebp-40h],eax 

Creating instances with default values:

 bool[] abPrimes2 = new[] { false, false }; 000000c0 mov edx,2 000000c5 mov ecx,79114A46h 000000ca call FD3006F0 000000cf mov dword ptr [ebp-68h],eax 000000d2 mov eax,dword ptr [ebp-68h] 000000d5 mov dword ptr [ebp-54h],eax 000000d8 mov eax,dword ptr [ebp-54h] 000000db mov dword ptr [ebp-5Ch],eax 

Answer 4

It is impossible to avoid initializing each slot in the array with the default value, at least at the IL level.

A string is a class, not a structure.

This means that A, B, C, D and Surrey can be stored in any position. A, B, C and D can be obtained from the internal pool that the reference to the object can be dynamic.

But I believe that JIT can be smart enough to reduce half this overhead.

PS. Premature optimization is the root of all evil.