Meilleures pratiques pour les conventions de dénomination de l'interface graphique C #?
Les interfaces graphiques, qu'elles soient écrites dans WinForms ou XAML, semblent avoir les conventions de dénomination les plus différentes entre les projets que je vois. Pour un simple TextBox pour le nom d'une personne, j'ai vu diverses conventions de dénomination:
TextBox tbName // Hungarian notation
TextBox txtName // Alternative Hungarian
TextBox NameTextBox // Not even camelCase
TextBox nameTextBox // Field after field with TextBox on the end
TextBox TextBoxName // Suggested in an answer...
TextBox textBoxName // Suggested in an answer...
TextBox uxName // Suggested in an answer...
TextBox name // Deceptive since you need name.Text to get the real value
TextBox textBox1 // Default name, as bad as you can get
Je respecte les règles StyleCop pour tous mes fichiers .cs normalement et je vois que d'autres le font également, mais l'interface graphique a tendance à enfreindre ces règles ou à varier énormément. Je n'ai vu aucune directive Microsoft qui se réfère spécifiquement aux éléments de l'interface graphique au lieu de simplement des variables normales, ou même des exemples qui s'appliqueraient en dehors d'une application console.
Quelles sont les meilleures pratiques pour nommer les éléments dans une interface graphique?
J'utilise le old school hongrois ... txt pour TextBox, btn pour Button, suivi d'un mot généralisé, puis d'un mot plus spécifique. c'est à dire.:
btnUserEmail
Beaucoup de gens ont dit des choses comme "omg thats so old, VB6 calling!" Mais dans une application winforms UI Rich, je peux trouver et modifier les choses sont plus rapides parce que généralement la première chose que vous savez sur un contrôle est son type, puis sa catégorie, puis devenez spécifique. Alors que la convention de dénomination de style plus récent, les gars sont bloqués à essayer de se souvenir de ce qu'ils ont nommé cette zone de texte.
La spécification d'origine pour les contrôles est ici (archivée).
J'utilise:
TextBox nameTextBox;
Tout comme j'utiliserais:
MailAddress homeAddress;
La raison en est que dans ces cas, "TextBox" et "Address" sont descriptifs de ce que l'objet représente, pas de la façon dont il est stocké ou utilisé. Mais dans un autre cas, comme stocker le nom complet d'une personne, j'utiliserais:
string fullName;
Ne pas:
string fullNameString;
Parce que "String" n'est pas descriptif de ce que l'objet représente, mais seulement comment il est stocké.
Même convention que tout le reste dans .NET: nom descriptif de la case camel uniquement, éventuellement suivi d'un suffixe si vous devez distinguer différentes classes pour la même "chose" logique. Par exemple:
string name; // a name
TextBox nameText; // the control used to edit the name
Label nameLabel; // the control used to label the edit control
List<string> nameList; // a list of names
et ainsi de suite à l'infini. Peu importe ce que sont les suffixes tant qu'ils sont cohérents et descriptifs.
Ce n'est pas mon invention, mais j'aime ça:
TextBox uxName = new TextBox();
Label uxNameLabel = new Label();
Button uxAccept = new Button();
Je préfère cela à la notation hongroise car tous mes contrôles d'interface utilisateur s'affichent dans un bloc en intelisense. UX pour "User eXperience". C'est aussi bien si vous changez un contrôle d'une zone de texte en une zone de liste déroulante ou quelque chose, car le nom ne changera pas.
J'aimerais que quelqu'un devienne l'autorité sur ce sujet et le dis simplement tel qu'il est, et commence à l'appliquer ... Le pire pour moi, c'est quand les gens le mélangent dans la même application ou pire encore dans la même classe.
J'ai vu des trucs assez horribles avec txtName, NameTextBox, name et textBox1 tous utilisés sous la même forme ... beurk.
Là où je travaille, nous avons un document sur les normes qui nous dit comment le faire, où le faire, et je pense que seulement 20% des gens se soucient même d'essayer de se conformer.
Je changerai habituellement quelque chose si Fxcop me crie dessus.
http://en.wikipedia.org/wiki/Naming_conventions_%28programming%29
Notez que: Microsoft .NET recommande UpperCamelCase (alias "Pascal Style") pour la plupart des identifiants. (LowerCamelCase est recommandé pour les paramètres).
La chose la plus importante à propos des conventions de dénomination est de choisir quelque chose qui a du sens, d'obtenir un consensus de toutes les parties et de s'y tenir comme si votre vie en dépendait.
Quant à la convention à utiliser, je voterais pour celle-ci:
TextBox name
Il est court et a une valeur sémantique comme identifiant. En ce qui concerne le type de l'identifiant, je m'appuierais sur Visual Studio pour vous dire que cela a tendance à être bon dans ce genre de chose.
J'utilise la notation Hungation avec une petite différence.
Je travaille maintenant sur un projet qui a une interface utilisateur assez riche. Ainsi, trouver, avec Intellisense, un bouton appelé, disons, btnGetUsers est très facile.
Les choses se compliquent lorsque l'application est en mesure d'obtenir des utilisateurs de différents endroits. Ce sont des contrôles différents. J'ai donc commencé à nommer mes contrôles d'après leur emplacement et j'utilise toujours la notation hongroise.
Par exemple: tabSchedAddSchedTxbAdress signifie que txbAddress est une zone de texte où une adresse peut être insérée et se trouve sur l'onglet Ajouter une planification à partir du contrôle de l'onglet Planification. De cette façon, je peux trouver les commandes très facilement et, lorsque je tape simplement "btn", je n'ai pas, à la fois, beaucoup de boutons de partout dans l'interface utilisateur.
Bien sûr, c'est juste pour m'aider. Je ne connais pas une telle meilleure pratique. Mais cela aide beaucoup.
Mosu '
Je nomme tous mes éléments d'interface utilisateur TypeDescriptor. Suivant votre exemple, TextBoxName.
J'ai tendance à utiliser c_typeName (veuillez noter que le type et le nom sont différents), par exemple c_tbUserEmail pour un TextBox dans lequel l'utilisateur doit taper son e-mail. Je le trouve utile car quand il y a beaucoup de contrôles, il peut être difficile de les trouver dans la liste intellisense longue de plusieurs kilomètres, donc en ajoutant le préfixe c_, je peux facilement voir tous les contrôles sous cette forme.
J'ai récemment travaillé avec une équipe qui passe de MFC (6.0 ...). Là, ils auraient quelque chose comme
CString Name;
CEdit ctlName;
La façon la plus simple de migrer a été d'utiliser quelque chose comme
TextBox ctlName
C'est juste un rappel suffisant que la variable est le contrôle et non la valeur du contrôle.
Je pense que l'inclusion du type dans le nom est juste VIEILLE.
- modifier - Un autre avantage est que tous les contrôles sont regroupés lors de la navigation. Si le type réel était utilisé, les contrôles ComboBox seraient assez loin des contrôles TextBox.
Cette folie hongroise/VB6 doit cesser.
Si Microsoft voulait vraiment que vous nommiez vos contrôles en fonction de leur type, pourquoi Visual Studio ne claque-t-il pas automatiquement le "txt" ou le "btn" lorsque vous ajoutez le contrôle à votre formulaire Web/Win?
Ma propre pratique est: Tapez _contextDescriptionType. Par exemple.:
TextBox _searchValueTextBox
Quoi qu'il en soit, la convention de dénomination est soit trop personnelle, soit imposée par des règles générales. Dans tous les cas, il doit être documenté quelque part afin que tous les développeurs de projets puissent y accéder facilement.
Vous avez le Guidelines for Names de Microsoft. Je ne suis pas tout suivre, mais c'est un bon point de départ
Je crois que la convention de dénomination existe pour faciliter l'effort de codage des développeurs et aide à la gestion. À ma connaissance, tout nom utile pour un accès facile doit être suivi.
J'ai vu un certain nombre de commentaires avec une approche différente, mais le meilleur que j'ai trouvé dans mes projets est de préfixer les trois premiers noms de contrôle. Il y a beaucoup de raisons derrière cette approche.
- Intellisense rassemblerait tous les mêmes types.
- Les fenêtres de propriétés de formulaire afficheraient également le même contrôle trié
- Sur les formulaires complexes, vous pouvez facilement identifier que vous traitez avec une étiquette ou une zone de texte (par exemple, lblAccounts et txtAccounts)
- Un nouvel utilisateur peut facilement gérer le codage.
- Imaginez que j'ai les contrôles accountLst, accountlbl, accounttxt, accountgrd, accountChk sur le même formulaire.
Lors du codage, un développeur sait toujours qu'il accède à une zone de texte ou à une étiquette. Où comme il ne sait pas avec quel nom l'autre développeur a utilisé. Donc, en écrivant simplement "lbl", intellisens amènerait toute la liste d'étiquettes à choisir, où est si vous avez utilisé l'approche utilisée dans # 5 alors intellisense apporterait tous les contrôles en utilisant acc. J'ai rarement vu faire une boucle avec un nom de contrôle commençant par "compte" ou plus. Cela signifie que cela n'aiderait en aucun cas rare.
Mon pari est de faire des choses qui aident à comprendre le code facilement pour un autre développeur. Parce qu'en grandissant dans votre porte-bébé, vous ne feriez pas toujours du codage, une autre personne viendrait s'asseoir.
Le choix vous appartient, comme vous le souhaitez!
J'utilise la notation hongroise, qui facilite la recherche de commandes dans les grandes pages.
Pour les éléments que je ne prévois pas d'utiliser dans mon code, je laisse juste le concepteur s'en occuper pour moi; s'ils deviennent quelque chose utilisé dans mon code, ils sont changés en quelque chose de significatif et qui se trouve être descriptionType (nameTextBox). C'est ainsi que le concepteur les crée s'il reçoit suffisamment d'informations (consultez les éléments de menu - "Quitter" devient exitMenuItem).
S'il y a une bonne séparation des préoccupations dans la conception d'une application, je suppose qu'il n'y aura pas besoin de nommer des boutons comme LoginButton, LoginBtn ou btnLogin. Si le propriétaire de l'objet est un élément d'interface utilisateur, appelons-le donc Login et si le propriétaire n'est pas un élément d'interface utilisateur, l'objet est au mauvais endroit.