fa C# Collection inizializzazione Sintassi evitare il default di inizializzazione Overhead

Question

Quando si utilizza la nuova sintassi C# collezione di inizializzazione:

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

fa l'evitano il compilatore inizializzazione ogni slot array per il valore di default, o è equivalente a:

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

Answer 1

il compilatore utilizza ancora l'istruzione newarr iL, così il CLR sarà ancora inizializzare l'array.

L'inizializzazione della raccolta è solo Magia del compilatore: il CLR non ne sa nulla, quindi supporrà che debba ancora fare lo sdoganamento.

Tuttavia, questo dovrebbe essere veramente, molto veloce - è solo la cancellazione della memoria. Dubito che sia un sovraccarico significativo in molte situazioni.

Answer 2

prova rapida:

 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(); 

risultati in questo IL (nota, sono entrambi identici)

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

ho fatto un breve test su instantianting un array utilizzando la sintassi si descrive e trovato che l'istanziazione con valori non predefiniti richiedeva circa 2,2 volte più dell'istantianizzazione con i valori predefiniti.

Quando passavo e creavo un'istanza con valori predefiniti, ci vuole circa lo stesso tempo.

Infatti, quando ho guardato il decompilare, sembra che ciò che accade è l'array inizializzato, e quindi viene popolato con qualsiasi valore che non sia il default.

Instantiating con valori non predefiniti:

  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 

un'istanza con valori di default:

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

Non è possibile evitare l'inizializzazione ogni slot matrice sul valore predefinito, almeno nel livello IL.

La stringa è una CLASSE, non una struttura.

Ciò significa che A, B, C, D e il sarray potrebbero essere memorizzati in qualsiasi posizione. A, B, C e D potrebbero essere prelevati dal pool Intern, affinché il riferimento all'oggetto possa essere dinamico.

Ma credo che il JIT potrebbe essere abbastanza intelligente da ridurre la metà di queste spese generali.

PS. L'ottimizzazione prematura è la radice di tutti i mali.