Quando utilizzare Constructor e quando utilizzare Collection Initializer?

Question

Quando utilizzare Constructor e quando utilizzare Collection Initializer?

#1 da (5 voti)
#2 da (1 voti)

4

Sto avendo una classe .Net che ha 10 proprietà come di seguito indicate: [i tipi di dati della singola proprietà sono solo un segnaposto qui e può essere qualsiasi cosa, da un tipo primitivo a un oggetto a un elenco di oggetti]

class MyClass
{
   internal int Property1{Get;Set;}
   internal string Property2{Get;Set;}
   internal Myclass2 Property3{Get;Set;}
   internal MyAnotherClass Property4{Get;Set;}   
   internal int Property5{Get;Set;}
   internal int Property6{Get;Set;}
   internal List<string> Property7{Get;Set;}
   internal int Property8{Get;Set;}
   internal MyThirdClass Property9{Get;Set;}
   internal int Property10{Get;Set;}
}

Lo scopo di questa classe è di conservare solo i dati e questa classe non avrà alcun comportamento di funzione [simile alle classi POCO]. Ora sto cercando di capire qui, come dovrei creare un costruttore parametrico nella classe e passargli tutti i valori per impostare queste proprietà o dovrei usare il Collection Initializer per impostare queste proprietà.

In tutti i casi, tutte le proprietà dovrebbero essere impostate in modo tale che non vi sia alcuna possibilità di impostare proprietà selettive.

Se procedo con l'approccio dell'utilizzo del costruttore, creo i membri privati per ciascuna di queste proprietà e li uso all'interno del costruttore per assegnargli i rispettivi valori. Questo eviterà di chiamare 10 metodi Setter solo per creare un oggetto di MyClass, ma creerà un costruttore che accetta 10 parametri.

Esiste una documentazione che spiega in quale caso si consiglia di utilizzare il costruttore anziché Collection Initializer e Vise a versa? Personalmente preferisco la creazione di Costruttore.

c# constructors initialization

posta GawdePrasad 09.10.2015 - 13:00

fonte

2 risposte

1

Da quello che hai descritto, sembra che abbia più senso avere un costruttore con 10 parametri e rendere privati i setter della proprietà.

All'interno del costruttore, assegneresti le proprietà dai parametri.

Una discussione che viene eseguita ed eseguita è se si debba impostare la variabile membro direttamente nel setter piuttosto che usare una proprietà. Sì, c'è un impatto minimo sulle prestazioni, ma IMHO è sintatticamente preferibile riferirsi allo storage di proprietà direttamente nel costruttore e alla proprietà altrove.

Per quanto riguarda il momento in cui useresti costruttori o proprietà, ciò dipende dal design. Se ci sono collezioni note di proprietà che desideri impostare, potresti voler creare un numero di costruttori. In alternativa, si potrebbe desiderare di consentire un costruttore vuoto e l'utente può impostare le proprietà che desidera. Chiaramente il costruttore dà più controllo in quanto alcune proprietà possono avere determinate regole di business. In definitiva, è una decisione di progettazione: non esistono regole empiriche da applicare qui.

risposta data 09.10.2015 - 13:23

fonte

Leggi altre domande sui tag c# constructors initialization

Come conservare i record con struttura variabile? Quale modello descrive meglio il disaccoppiamento della costruzione di file dal formato del file di output?

score 5 · Accepted Answer

Poiché si tratta di una classe interna, non vi è alcun vantaggio nell'uso delle proprietà di lettura / scrittura automatiche; stai creando molti metodi get / set nel tuo IL risultante.

Supponendo che stai usando C # 6, hai due opzioni:

1 Rendi invariabile la classe:

internal class MyClass
{
    internal MyClass(int property1, int property2, int property3, int property4, int property5, 
                     int property6, int property7, int property8, int property9, int property10)
    {
        Property1 = property1;
        Property2 = property2;
        Property3 = property3;
        Property4 = property4;
        Property5 = property5;
        Property6 = property6;
        Property7 = property7;
        Property8 = property8;
        Property9 = property9;
        Property10 = property10;
    }

    internal int Property1 { get; }
    internal int Property2 { get; }
    internal int Property3 { get; }
    internal int Property4 { get; }
    internal int Property5 { get; }
    internal int Property6 { get; }
    internal int Property7 { get; }
    internal int Property8 { get; }
    internal int Property9 { get; }
    internal int Property10 { get; }
}

Lo svantaggio di questo approccio è che ora hai un costruttore con dieci parametri, che è un odore di codice definito ed ingombrante da usare.

2 Usa i campi e inizializza la classe tramite un inizializzatore dell'oggetto:

internal class MyClass
{
    internal int Property1;
    internal int Property2;
    internal int Property3;
    internal int Property4;
    internal int Property5;
    internal int Property6;
    internal int Property7;
    internal int Property8;
    internal int Property9;
    internal int Property10;
}

...

var x = new MyClass
{
    Property1 = 1,
    Property2 = 1,
    Property3 = 1,
    Property4 = 1,
    Property5 = 1,
    Property6 = 1,
    Property7 = 1,
    Property8 = 1,
    Property9 = 1,
    Property10 = 1,
};

Lo svantaggio di questo approccio è che ora hai un oggetto dati mutabile, che è improbabile che sia quello che vuoi.

Un modo per aggirare questo è di ridimensionare la classe in un numero di classi separate, ognuna con 3-4 valori. Se questo è pratico o auspicabile nel tuo caso è difficile dire che il tuo esempio non ha alcuna informazione su quali siano i veri valori.