Ordre des éléments dans les classes: champs, propriétés, constructeurs, méthodes
Existe-t-il une directive officielle C # pour l'ordre des éléments en termes de structure de classe?
Est-ce qu'il va:
- Champs publics
- Champs privés
- Propriétés
- Constructeurs
- Les méthodes
?
Je suis curieux de savoir s'il existe une règle stricte concernant l'ordre des éléments? Je suis un peu partout. Je veux m'en tenir à une norme particulière afin de pouvoir le faire partout.
Le vrai problème est que mes propriétés les plus complexes finissent par ressembler beaucoup à des méthodes et qu’elles ne se sentent pas à leur place au sommet avant le constructeur.
Des conseils/suggestions?
Selon le StyleCop Rules Documentation , l'ordre est le suivant.
Dans une classe, une structure ou une interface: (SA1201 et SA1203)
- Champs constants
- Des champs
- Constructeurs
- Finalizer (Destructors)
- Les délégués
- Événements
- Enums
- Interfaces ( implémentations d'interface )
- Propriétés
- Indexeurs
- Les méthodes
- Structs
- Des classes
Dans chacun de ces groupes, commandez par accès: (SA1202)
- publique
- interne
- interne protégé
- protégé
- privé
Dans chacun des groupes d’accès, effectuez un ordre statique, puis non statique: (SA1204)
- statique
- non statique
Dans chacun des groupes de champs statiques/non statiques, commandez en lecture seule, puis non en lecture seule: (SA1214 et SA1215)
- lecture seulement
- non en lecture seule
Une liste déroulée compte 130 lignes, je ne la déroulerai donc pas ici. La partie méthodes déroulée est:
- méthodes statiques publiques
- méthodes publiques
- méthodes statiques internes
- méthodes internes
- méthodes statiques internes protégées
- méthodes internes protégées
- méthodes statiques protégées
- méthodes protégées
- méthodes statiques privées
- méthodes privées
La documentation indique que si l'ordre prescrit n'est pas adapté (par exemple, plusieurs interfaces sont en cours d'implémentation et que les méthodes et les propriétés d'interface doivent être regroupées), utilisez ensuite une classe partielle pour regrouper les méthodes et les propriétés associées.
Plutôt que de regrouper par visibilité ou par type d'élément (champ, propriété, méthode, etc.), qu'en est-il du regroupement par fonctionnalité?
C’est une question ancienne mais toujours très pertinente, je vais donc ajouter ceci: quelle est la première chose que vous recherchez lorsque vous ouvrez un fichier de classe que vous avez peut-être déjà lu ou pas? Des champs? Propriétés? J'ai réalisé par expérience que j'allais presque toujours à la recherche des constructeurs, car la chose la plus fondamentale à comprendre est la manière dont cet objet est construit.
Par conséquent, j'ai commencé à placer les constructeurs en premier dans les fichiers de classe et le résultat a été psychologiquement très positif. La recommandation standard de mettre les constructeurs après un tas d'autres choses semble dissonante.
La fonctionnalité de constructeur primaire à venir en C # 6 indique que l'emplacement naturel d'un constructeur se situe tout en haut d'une classe. En fait, les constructeurs primaires sont spécifiés même avant l'accolade ouverte.
C'est drôle de voir à quel point une réorganisation comme celle-ci fait toute la différence. Cela me rappelle la manière dont les instructions using étaient classées - avec les espaces de noms système en premier. La commande "Organiser les utilisations" de Visual Studio a utilisé cet ordre. Maintenant, usings sont simplement classés par ordre alphabétique, sans aucun traitement particulier pour les espaces de noms System. Le résultat est simplement plus simple et plus propre.
Je recommanderais d'utiliser les normes de codage de IDesign ou celles répertoriées sur site Web de Brad Abram . Ce sont les deux meilleurs que j'ai trouvés.
Brad dirait ...
Les membres de classes doivent être classés par ordre alphabétique et regroupés en sections (champs, constructeurs, propriétés, événements, méthodes, implémentations d'interface privée, types imbriqués).
Je ne connais pas de langage ou de norme de l'industrie, mais j'ai tendance à mettre les choses dans cet ordre, chaque section étant entourée d'une # région:
en utilisant des déclarations
Espace de noms
Classe
Membres privés
Propriétés publiques
Constructeurs
Méthodes publiques
Méthodes privées
D'habitude j'essaie de suivre le modèle suivant:
- membres statiques (ont généralement un autre contexte, doivent être thread-safe, etc.)
- membres d'instance
Chaque partie (statique et instance) comprend les types de membres suivants:
- opérateurs (toujours statiques)
- champs (initialisés avant les constructeurs)
- constructeurs
- destructor ( est une tradition pour suivre les constructeurs )
- propriétés
- les méthodes
- événements
Ensuite, les membres sont triés par visibilité (de moins en plus visible):
- privé
- interne
- interne protégé
- protégé
- publique
L'ordre n'est pas un dogme: les classes simples sont plus faciles à lire, cependant, les classes plus complexes nécessitent un regroupement spécifique au contexte.
De StyleCop
champs privés, champs publics, constructeurs, propriétés, méthodes publiques, méthodes privées
Comme StyleCop fait partie du processus de construction de MS, vous pouvez le considérer comme un standard de facto.
Comme mentionné précédemment, rien dans le langage C # ne dicte la mise en page. Personnellement, j'utilise des régions et je fais quelque chose comme cela pour une classe moyenne.
public class myClass
{
#region Private Members
#endregion
#region Public Properties
#endregion
#region Constructors
#endregion
#region Public Methods
#endregion
}
C'est logique pour moi quand même
Ma préférence va à la commande par genre et ensuite à la visibilité décroissante comme suit
public methods
public events
public properties
protected methods
protected events
protected properties
private methods
private events
private properties
private fields
public delegates
public interfaces
public classes
public structs
protected delegates
protected interfaces
protected classes
protected structs
private delegates
private interfaces
private classes
private structs
Je sais que cela viole Style Cop et si quelqu'un peut me donner une bonne raison de placer les détails d'implémentation d'un type avant son interface, je suis disposé à changer. À l’heure actuelle, j’ai une forte préférence pour le fait de mettre les membres privés en dernier.
Remarque: je n'utilise pas de champs publics ou protégés.
Vous trouverez probablement "Guide de conception, code managé et .NET Framework" ( http://blogs.msdn.com/brada/articles/361363.aspx ) par Brad Abrams
De nombreuses normes sont décrites ici. La section pertinente est 2.8 je pense.
Je préfère placer les champs privés en haut avec le ou les constructeurs, puis placer les bits d'interface publique après cela, puis les bits d'interface privée.
De plus, si votre définition de classe est suffisamment longue pour que l'ordre des éléments ait beaucoup d'importance, c'est probablement un odeur de code indiquant que votre classe est trop volumineuse et complexe et que vous devez le refactoriser.
Je le garde aussi simple que possible (pour moi du moins)
Énumérations
Déclarations
Constructeurs
Remplacements
Méthodes
Propriétés
Gestionnaire d'événements
les seules directives de codage suggérées à cet effet consistent à placer les champs en haut de la définition de la classe.
j'ai tendance à mettre les constructeurs à côté.
mon commentaire général serait que vous devriez vous en tenir à une classe par fichier et si la classe est suffisamment grande pour que l'organisation des propriétés par rapport aux méthodes soit un gros problème, quelle est la taille de la classe et devriez-vous la refactoriser de toute façon? cela représente-t-il de multiples préoccupations?
Il n’ya certainement rien dans le langage qui l’impose de quelque manière que ce soit. J'ai tendance à regrouper les éléments par visibilité (public, puis protégé, puis privé) et à utiliser #regions pour regrouper les éléments liés de manière fonctionnelle, qu'il s'agisse d'une propriété, d'une méthode ou autre. Les méthodes de construction (qu’il s’agisse de calculateurs réels ou de fonctions statiques d’usine) sont généralement au sommet de la hiérarchie, car c’est la première chose que les clients doivent connaître.
Je sais que c'est vieux mais ma commande est la suivante:
en ordre de public, protected, private, internal, abstract
- Constantes
- Variables statiques
- Des champs
- Événements
- Constructeur (s)
- Les méthodes
- Propriétés
- Les délégués
J'aime aussi écrire des propriétés comme celle-ci (au lieu de l'approche abrégée)
// Some where in the fields section
private int someVariable;
// I also refrain from
// declaring variables outside of the constructor
// and some where in the properties section I do
public int SomeVariable
{
get { return someVariable; }
set { someVariable = value; }
}