Ci sono degli svantaggi nell'uso di un inizializzatore di oggetti vuoto?

Question

sto facendo una revisione del codice e ha trovato una linea in cui uno dei nostri sviluppatori è la creazione di un oggetto utilizzando un inizializzatore oggetto vuoto come questo:

List<Floorplan> floorplans = new List<Floorplan> { }; 

non so perché avrebbe un'istanza in questo modo, piuttosto che :

List<Floorplan> floorplans = new List<Floorplan>(); 

Ci sono dei lati negativi per l'istanziazione degli oggetti utilizzando gli inizializzatori di oggetti vuoti? Oltre ad essere stilisticamente incoerente, voglio sapere se c'è un motivo per evitare questo approccio. Qualcosa mi dice questo odore ma voglio essere sicuro prima di dire qualcosa.

Answer 1

Il risultato compilato è lo stesso.

Il seguente C#:

static void Main() 
{ 
    var x = new List<int>(); 
    var y = new List<int> { }; 
} 

compila in quanto segue IL:

.method private hidebysig static 
    void Main() cil managed 
{ 
    // Method begins at RVA 0x2050 
    // Code size 14 (0xe) 
    .maxstack 1 
    .entrypoint 
    .locals init (
     [0] class [mscorlib]System.Collections.Generic.List`1<int32> x, 
     [1] class [mscorlib]System.Collections.Generic.List`1<int32> y 
    ) 

    IL_0000: nop 
    IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor() 
    IL_0006: stloc.0 
    IL_0007: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor() 
    IL_000c: stloc.1 
    IL_000d: ret 
} // end of method Program::Main 

Se si aggiunge un valore alle collezioni:

static void Main() 
{ 
    var x = new List<int>(); 
    x.Add(1); 
    var y = new List<int> { 1 }; 
} 

Questa è la risultante IL:

.method private hidebysig static 
    void Main() cil managed 
{ 
    // Method begins at RVA 0x2050 
    // Code size 32 (0x20) 
    .maxstack 2 
    .entrypoint 
    .locals init (
     [0] class [mscorlib]System.Collections.Generic.List`1<int32> x, 
     [1] class [mscorlib]System.Collections.Generic.List`1<int32> y, 
     [2] class [mscorlib]System.Collections.Generic.List`1<int32> '<>g__initLocal0' 
    ) 

    IL_0000: nop 
    IL_0001: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor() 
    IL_0006: stloc.0 
    IL_0007: ldloc.0 
    IL_0008: ldc.i4.1 
    IL_0009: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0) 
    IL_000e: nop 
    IL_000f: newobj instance void class [mscorlib]System.Collections.Generic.List`1<int32>::.ctor() 
    IL_0014: stloc.2 
    IL_0015: ldloc.2 
    IL_0016: ldc.i4.1 
    IL_0017: callvirt instance void class [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0) 
    IL_001c: nop 
    IL_001d: ldloc.2 
    IL_001e: stloc.1 
    IL_001f: ret 
} // end of method Program::Main 

Questo mostra come gli inizializzatori di raccolta sono solo zucchero di sintassi. Poiché gli inizializzatori di raccolta non erano originariamente parte di C#, penso che le persone siano più abituate alla sintassi del costruttore. Se mi sono imbattuto in un codice che utilizzava un inizializzatore di raccolta vuoto, mi chiedo perché, ma certamente non ha alcun problema di leggibilità. Se uno è abbastanza intelligente da capire il codice, allora {} vs () non dovrebbe essere così sconvolgente da minare la capacità di una persona di comprendere ciò che il codice sta facendo.Si tratta di una questione di opinione. Fai quello su cui la tua squadra è d'accordo, e se sei solo tu, allora usalo per i tuoi cuori.

Answer 2

Non vi è alcun motivo per cui l'inizializzazione { } debba essere utilizzata lì, quindi direi di rimuoverla. Lo sviluppatore sta utilizzando l'inizializzatore della raccolta statica. L'unico motivo per cui lo fai è che puoi iniziare la raccolta con alcuni oggetti, dato che non ce ne sono, non ha senso. Detto questo, il risultato sarà una raccolta vuota, proprio come se chiamasse normalmente il costruttore.

Answer 3

In questo caso non ci sono aspetti negativi, ma è preferibile la leggibilità. Se non hai bisogno delle parentesi aggiuntive durante l'istanziazione, non usarle in modo semplice e chiaro.

Direi che preferisco la produttività. Molte delle risposte qui stanno andando più in profondità nel tentativo di rispondere a questa domanda. Anche se una tecnica fosse migliore dell'altra, stiamo parlando di ciò che è davvero una micro ottimizzazione.

Answer 4

Sono praticamente uguali, ma l'utilizzo del costruttore predefinito è più leggibile.

Answer 5

Ci sono molti commenti che dicono "il costruttore predefinito è più leggibile". Non c'è alcun motivo per supporre che () sia più (o meno) leggibile di {}, quindi stai effettivamente prendendo un sondaggio di opinione qui.

Se sei preoccupato per la correttezza, il codice del tuo collega va bene. Se sei preoccupato per gli standard di codifica, dovresti assicurarti che il codice sia cambiato in modo che corrisponda al tuo standard (qualunque sia lo standard).