web-dev-qa-db-fra.com

Quelle est la meilleure façon de mettre en page une classe C #?

Existe-t-il un moyen standard de disposer un fichier C #? Comme dans, Champs, puis Propriétés, puis Constructeurs, etc.?

Voici ce que je fais normalement, mais je me demande s'il existe une méthode standard?

  1. Classes ou énumérations imbriquées
  2. Des champs
  3. Propriétés
  4. Événements
  5. Constructeurs
  6. Méthodes publiques
  7. Méthodes privées

Les gens regroupent-ils leurs champs ou les mettent-ils avec les propriétés? Ou les gens ne se soucient-ils pas d'une commande? Visual Studio semble rendre la tâche si difficile.

Edit : Déplacement d'une autre partie sur ReSharper ici: Faites en sorte que Resharper respecte votre préférence pour l'ordre des codes.

c#coding-style
40
Ray

J'ai tendance à utiliser Microsoft StyleCop , qui a un ordre défini selon la règle SA1201 :

Cause Un élément dans un fichier de code C # est en désordre par rapport aux autres éléments du code.

Description de la règle Une violation de cette règle se produit lorsque les éléments de code dans un fichier ne suivent pas un schéma de classement standard.

Pour se conformer à cette règle, les éléments au niveau de la racine du fichier ou dans un espace de noms doivent être positionnés dans l'ordre suivant:

  • Directives d'alias externes
  • Utilisation des directives
  • Espaces de noms
  • Délégués
  • Enums
  • Interfaces
  • Structs
  • Des classes

Dans une classe, une structure ou une interface, les éléments doivent être positionnés dans l'ordre suivant:

  • Des champs
  • Constructeurs
  • Finaliseurs (destructeurs)
  • Délégués
  • Événements
  • Enums
  • Interfaces
  • Propriétés
  • Indexeurs
  • Méthodes
  • Structs
  • Des classes

Le respect d'un schéma de classement standard basé sur le type d'élément peut augmenter la lisibilité et la maintenabilité du fichier et encourager la réutilisation du code.

Lors de la mise en œuvre d'une interface, il est parfois souhaitable de regrouper tous les membres de l'interface les uns à côté des autres. Cela nécessitera parfois de violer cette règle, si l'interface contient des éléments de types différents. Ce problème peut être résolu grâce à l'utilisation de classes partielles.

  1. Ajoutez l'attribut partiel à la classe, si la classe n'est pas déjà partielle.

  2. Ajoutez une deuxième classe partielle avec le même nom. Il est possible de le placer dans le même fichier, juste en dessous de la classe d'origine, ou dans un deuxième fichier.

  3. Déplacez l'héritage d'interface et tous les membres de l'implémentation d'interface vers la deuxième partie de la classe.

58
chills42

Je pense qu'il n'y a pas meilleur moyen. Il y a deux choses importantes à considérer en matière de mise en page. La première chose la plus importante est la cohérence. Choisissez une approche et assurez-vous que toute l'équipe accepte et applique la mise en page. Deuxièmement, si votre classe devient suffisamment grande pour que vous cherchiez où ces propriétés embêtantes vivent (ou que vous devez implémenter des régions pour les rendre plus faciles à trouver), alors votre classe est probablement trop grande. Pensez à le renifler et à le refactoriser en fonction de ce que vous sentez.

Pour répondre à la question de remodelage, vérifiez sous Type de disposition des membres dans Options (sous le nœud C #). Ce n'est pas simple, mais il est possible de changer l'ordre de mise en page.

9
Michael Meadows

Je ne pense pas que les régions soient nécessairement le signe d'un mauvais code. Mais pour déterminer que vous devrez revoir ce que vous avez. Comme je l'ai dit ici c'est ainsi que je régionaliser mon code.


Énumérations
Déclarations
Constructeurs
Méthodes
Gestionnaires d'événements
Propriétés

Mais l'essentiel est de le garder cohérent et ciblé.

2
Pat

Vous pouvez essayer Regionerate pour vous aider. Je l'aime vraiment et c'est un choix de Scott Hanselman.

1
Daver

J'ai tendance à regrouper les données privées et à regrouper les méthodes/propriétés associées dans des groupes fonctionnels.

public class Whatever {
   // private data here
   int _someVal = kSomeConstant;

   // constructor(s)
   public Whatever() { }

#region FabulousTrick  // sometimes regionize it
   // fabulous trick code
   private int SupportMethodOne() { }
   private double SupportMethodTwo() { }
   public void PerformFabulousTrick(Dog spot) {
       int herrings = SupportMethodOne();
       double pieces = SupportMethodTwo();
       // etc
   }
#endregion FabulousTrick
   // etc
}
1
plinth

Comme je l'ai dit, je ne pense pas qu'il existe un meilleur moyen en tant que tel. Mais une organisation vous aide le programmeur.

Combien de fois dans un long projet avez-vous passé du temps à monter et descendre un ou plusieurs fichiers source à essayer de trouver l'une de vos fonctions.

Alors j'utilise le #region beaucoup de ce genre de manière -

  1. region Events: Toutes les références d'événements utilisées par cette classe (au moins dans cette classe partielle particulière).

  2. Contrôles de la région: Toutes les fonctions qui interagissent directement avec les contrôles d'un formulaire.

  3. region MDI: configurer le mdi

    Ensuite, il y en aura à voir avec la fonctionnalité plutôt que l'interface,

  4. recherche Regex par région

Je le invente au fur et à mesure, mais en utilisant le même modèle que j'utilise toujours. Je dois dire que certains programmeurs ramassant mon travail m'ont dit qu'il était facile à suivre et d'autres que c'était compliqué.

Vous pouvez faire plaisir à la moitié des gens la moitié du temps et l'autre moitié du temps et l'autre quart du temps, vous confondez tout le monde, y compris vous-même. Je pense que Winston Chrchil a dit cela.

1
Rob Rassler

Tout ce qui rend votre plus productif. Certains aiment les champs privés à côté des accesseurs de propriété, certains aiment les champs ensemble au-dessus des constructeurs. La plus grande chose qui peut aider est de regrouper des éléments "comme". J'aime personnellement rassembler méthodes privées, propriétés privées, etc.

Essayez certaines choses et encore, tout ce que vous pensez vous rend plus productif et vous aide à maintenir votre code à jour.

0
Chad Moran

Chacun à leur propre, mais j'ai tendance à suivre le même ordre que l'aide MSDN suit.

Je n'aime pas non plus imbriquer des classes ou des énumérations, mais plutôt créer des fichiers séparés pour eux, ce qui facilite également l'écriture des tests unitaires (car il est facile de trouver le fichier de test associé lorsque vous devez ajouter/corriger/refactoriser un test).

À mon humble avis, l'ordre n'est pas si important parce que VS facilite la recherche de tous les membres (surtout si vous suivez l'approche d'une classe/interface/enum par fichier), et Sandcastle les regroupera si vous souhaitez créer des documents, donc je ' d être plus préoccupé de leur donner des noms significatifs.

0
si618

En plus de conserver un ensemble cohérent de régions dans vos fichiers de classe, je garde tous les composants d'une région dans l'ordre alphabétique. J'ai tendance à avoir un peu de "mémoire visuelle" quand il s'agit de lire du code et cela me rend fou d'avoir à utiliser le menu déroulant de navigation pour trouver du code dans un fichier parce qu'il est partout.

0
womp

J'utilise la mise en page suivante:

événements globaux/champs à l'échelle de la classe méthodes de propriétés privées/internes méthodes de propriétés publiques/protégées classes imbriquées (même si j'essaye de les éviter autant que possible)

Je crois aussi fermement en 1 code "chose" (classe, interface ou enum) par fichier, avec le nom de fichier identique au nom de "chose". Oui, cela fait un projet plus grand mais cela facilite infiniment la recherche de choses.

0
Scott Dorman