Est-il une mauvaise pratique à l'extérieur des champs d'initialiser un constructeur explicite

Question

Possible en double:
Initialize class fields in constructor or at declaration?

Nous plaidons sur les pratiques de codage. Les exemples ici sont un peu trop simples, mais la vraie affaire a plusieurs constructeurs. Afin d'initialiser les valeurs simples (par exemple les dates à leur valeur min) j'ai déplacé le code hors des constructeurs et dans les définitions de champ.

public class ConstructorExample 
{ 
    string _string = "John"; 
} 

public class ConstructorExample2 
{ 
    string _string; 

    public ConstructorExample2() 
    { 
     _string = "John"; 
    } 
} 

Comment doit-il être fait par le livre? J'ai tendance à être très au cas par cas et donc je suis peut-être un peu laxiste à propos de ce genre de chose. Cependant, je pense que le rasoir occams me dit de déplacer l'initialisation de plusieurs constructeurs. Bien sûr, je pourrais toujours déplacer cette initialisation partagée dans une méthode privée.

La question est essentiellement ... est l'initialisation des champs où ils sont définis par opposition au constructeur mauvais en aucune façon?

L'argument que je suis confronté est une gestion des erreurs, mais je ne pense pas qu'il est pertinent car il n'y a aucune exception possible qui ne seront pas ramassées au moment de la compilation.

Answer 1

Ce n'est pas nécessairement mauvais pour initialiser des valeurs en dehors du constructeur, et le problème que vous avez ici:

string _string; 

    public ConstructorExample2() 
    { 
     _string = "John"; 
    } 

Est-ce que si vous avez plusieurs constructeurs vous devez vous rappeler soit
1. Réinitialiser _string dans chaque constructeur
2. Séparer la logique à une méthode en commun et appeler cette méthode dans tous les constructeurs
3. appelez le constructeur avec la logique en elle, des autres constructeurs. (Chaîne les constructeurs)
Maintenant, ce n'est pas nécessairement un problème, mais vous devez vous rappeler de le faire. En l'initialisant en dehors du constructeur, c'est fait pour vous. C'est une chose de moins que vous devez vous rappeler de faire.

Answer 2

Je préfère initialiser des champs simples comme ceux en dehors du constructeur.

Il ne devrait pas poser de problèmes puisque la compilation se déplace effectivement ces initialisations dans le constructeur à la compilation de toute façon.

Answer 3

Par défaut, Microsoft FxCop recommande d'initialiser les champs en utilisant le constructeur. This question est également une copie de celui-ci et devrait fournir un aperçu.

Avec les classes statiques, vous devrez noter quelques subtilités à l'adresse indiquée à this question.

Answer 4

Si l'initialisation de la variable sera le même, peu importe ce que les arguments sont transmis au constructeur, il n'a pas de sens encombrer la méthode constructeur avec le code d'initialisation inutile. Dans ce cas, j'initialise sur place.

Answer 5

Inialer les champs dans le constructeur est meilleur. De cette façon, si/quand un constructeur différent est ajouté, vous savez que tous les champs commencent avec des valeurs nulles/par défaut et vous pouvez les initialiser de manière appropriée.

Answer 6

Dans l'exemple ci-dessus l'attribution de « John » à _string n'a pas de dépendance logique sur toutes les variables et, par conséquent, il devrait être en dehors du constructeur dans le initialiseur sur le terrain.

Tant que ce n'est pas possible d'initialiser l'objet dans un état non utilisable alors il n'a pas d'importance.

Lorsque le code est compilé les deux approches seront les mêmes de toute façon.

Answer 7

Notez que toutes ces initialisation de niveau de déclaration terrain sera effectuée une fois pour chaque constructeur de la chaîne, même si le constructeur lui-même définit le champ à autre chose.

Si vous enchaînez les constructeurs ensemble, les champs seront initialisés dans la commune, tout d'abord, le constructeur qui est appelé.

Regardez cet exemple:

using System; 

namespace ClassLibrary3 
{ 
    public class Class1 
    { 
     private string _Name = "Lasse"; 

     public Class1() 
     { 
     } 

     public Class1(int i) 
      : this() 
     { 
     } 

     public Class1(bool b) 
     { 
      _Name = "Test"; 
     } 
    } 
} 

Ce code compile comme ceci:

using System; 

namespace ClassLibrary3 
{ 
    public class Class1 
    { 
     private string _Name; 

     public Class1() 
     { 
      _Name = "Lasse" 
     } 

     public Class1(int i) 
      : this() 
     { 
      // not here, as this() takes care of it 
     } 

     public Class1(bool b) 
     { 
      _Name = "Lasse" 
      _Name = "Test"; 
     } 
    } 
} 

Answer 8

ne suis pas sûr C#, mais dans le code source Java, ils semblent préférer le constructeur, par exemple:

public class String{ 
    char[] value; 
    int offset; 
    ... 
    public String(){ 
     value = new char[0]; 
     offset = 0; 
     ... 
    } 
} 

Answer 9

Je pense que pour les initialisations simples comme qu'il est bien de le faire dans la déclaration. Cependant, je ne comprends pas l'argument de gestion des erreurs. Même s'il y a une exception dans l'initialisation, je pense que vous constaterez que votre mécanisme normal de gestion des erreurs fonctionnera de la même manière. Il lèvera toujours une exception lorsque vous appelez le constructeur.

Answer 10

J'ai tendance à initialiser des choses dans l'accesseur get, où elles sont utilisées pour la première fois. Si null alors initialiser et tout ça.