En C#, quelle est la meilleure façon d'enchaîner les constructeurs?

Question

Compte tenu de la classe suivante:

public class MyClass 
{ 
    private string _param; 

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

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

Je suis déchiré entre deux façons de enchaînez les constructeurs:

Le premier:

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

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

Le second:

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

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

Alors, est-il préférable de chaîner à partir du constructeur sans paramètre ou l'inverse? Avec votre exemple, j'irais le premier chemin.

Answer 1

La seconde n'élimine en réalité aucune duplication de code que vous essayez d'éviter, puisque vous devez toujours définir explicitement _param. L'appel this() vide dans la deuxième approche est complètement gratuit.

Answer 2

Je préfère le premier. Le comportement des constructeurs sera toujours cohérent et prévisible de cette façon, en plus il réduit la duplication du code.

Answer 3

chaîne de pramater moins à pramater,

si vous appelez de bailleur constructeurs param avec vals par défaut pour plusieurs paramètres

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

public Myclass(value) 
{ 
    _value = value; 
} 

Answer 4

J'imagine qu'il est toujours préférable de la chaîne de moindre à une plus grande, à savoir pourquoi affecter une chaîne vide puis une chaîne donnée dans le constructeur quand il est plus logique de passer la valeur par défaut (string.Empty) au constructeur paramétré.

Answer 5

Si vous définissez votre objectif ici comme "fournir un défaut lorsqu'aucune valeur n'est spécifiée", alors vous devez utiliser clairement la première approche.

La règle générale serait alors: chaîne du constructeur le moins spécifique à la plus spécifique.

Answer 6

Je préfère aussi le premier. Tout comme dans une classe dérivée complexe héritant d'une classe de base simple, vous voulez que le constructeur "complexe" s'appuie sur la fonctionnalité de "base".

Answer 7

Deuxième exemple dans votre cas n'a vraiment pas de sens, puisque vous dupliquez l'affectation du membre de la classe (si vous utilisez le constructeur MyClass (string param)).

La deuxième approche est plus utile si les constructeurs chaînés "ajoutent des fonctionnalités".

Exemple:

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

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

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

Dans votre cas particulier, le premier exemple est évidemment beaucoup plus approprié, puisque vous avez une seule affectation au même membre.