In C#, qual è il modo migliore/accettato di fare concatenamento con il costruttore?

Question

Data la seguente classe:

public class MyClass 
{ 
    private string _param; 

    public MyClass() 
    { 
     _param = string.Empty; 
    } 

    public MyClass (string param) 
    { 
     _param = param; 
    } 
} 

sto lacerato tra due modi di catena di quei costruttori:

Il primo:

public MyClass() : this (string.Empty) 
{ 
} 

public MyClass (string param) 
{ 
    _param = param; 
} 

la seconda:

public MyClass() 
{ 
    _param = string.Empty; 
} 

public MyClass (string param) : this() 
{ 
    _param = param; 
} 

Quindi, è meglio concatenare dal costruttore senza parametri o viceversa?

Answer 1

Con il tuo esempio, farei la prima. Il secondo non elimina effettivamente la duplicazione del codice che si sta presumibilmente cercando di evitare, poiché è comunque necessario impostare in modo esplicito _param. La chiamata vuota this() nel secondo approccio è completamente gratuita.

Answer 2

Preferisco il primo. Il comportamento dei costruttori sarà sempre coerente e prevedibile in questo modo, oltre a ridurre la duplicazione del codice.

Answer 3

catena da pramater meno a pramater,

così chiamata da locatore costruttori param con vals di default per più parametri

public MyClass() 
{ 
    MyClass(default value here); 
} 

public Myclass(value) 
{ 
    _value = value; 
} 

Answer 4

mi immagino che è sempre meglio catena dalla minore ad una maggiore, vale a dire perché assegnare una stringa vuota quindi una determinata stringa nel costruttore quando ha più senso passare il valore predefinito (string.Empty) al costruttore parametrizzato.

Answer 5

Se si dichiara il proprio obiettivo qui come "fornire un valore predefinito quando non è specificato alcun valore", è necessario utilizzare chiaramente il primo approccio.

La regola generale sarebbe: catena da costruttore meno specifico a più specifico.

Answer 6

Preferisco anche il primo. Proprio come in una classe derivata complessa che eredita da una semplice classe base, si vuole che il costruttore "complesso" costruisca sulla funzionalità di quella "base".

Answer 7

Il secondo esempio nel tuo caso in realtà non ha senso, poiché si duplica l'assegnazione del membro della classe (se si utilizza il costruttore MyClass (string param)).

Il secondo approccio è più utile se i costruttori concatenati "aggiungono funzionalità".

Esempio:

public MyClass() 
{ 
    _param0 = string.Empty; 
} 

public MyClass (string param1) : this() 
{ 
    _param1 = param1; 
} 

public MyClass (string param1, string param2) : this (param1) 
{ 
    _param2 = param2; 
} 

Nel tuo caso particolare, il primo esempio è ovviamente molto più appropriato, dal momento che si dispone di una sola assegnazione allo stesso membro.