Les enums en C # doivent-ils avoir leur propre fichier?
J'ai une classe qui utilise une énumération, l'énumération est actuellement dans son propre fichier qui semble inutile.
Quelle est l'opinion générale sur les enums placés dans l'espace de noms d'un fichier dans lequel ils sont consommés? Ou bien l’énumération devrait-elle vraiment vivre dans son propre fichier cs?
Éditer
Je devrais mentionner que, bien que la classe en question utilise ces énumérations, les appelants externes font de même. En d'autres termes, une autre classe peut définir ces énumérations. Ils ne sont donc pas utilisés en interne par la classe, sinon cette question serait une évidence.
Je ne dirais pas "gaspillage" (combien coûte un fichier supplémentaire?), Mais c'est souvent dérangeant. Habituellement, il y a une classe qui est la plus étroitement associée à l'énum, et je les place dans le même dossier.
C'est vraiment juste une question de préférence.
Je préfère mettre chaque énumération dans son propre fichier (de la même manière pour chaque interface, classe et struct, si petit soit-il). Cela les facilite pour trouver quand je viens d'une autre solution ou autrement n'ont pas déjà une référence au type en question.
Mettre un seul type dans chaque fichier facilite également l'identification des modifications dans les systèmes de contrôle de source sans diffing.
Ceci est entièrement une question de style. Ce que j'ai tendance à faire, c'est d'avoir un fichier nommé Enums.cs dans la solution dans laquelle les déclarations d’énumération sont collectées.
Mais ils se trouvent généralement à travers le F12 clé quand même.
La question à vous poser est la suivante: existe-t-il un type d'énumération en C # qui indique que je devrais le traiter différemment de tous les autres types que je crée?
Si l'énumération est publique, elle doit être traitée comme tout autre type public. S'il est privé, déclarez-le en tant que membre imbriqué de la classe qui l'utilise. Il n'y a aucune raison impérieuse de placer deux types publics dans le même fichier simplement parce que l'un est une énumération. Le fait qu'il s'agisse d'un type public est tout ce qui compte; la saveur de type ne le fait pas.
Le contrôle de source est un autre avantage de placer chaque type (classe, struct, enum) dans son propre fichier. Vous pouvez facilement obtenir l'historique complet du type.
Je place la plupart du temps à l'intérieur de l'espace de noms et à l'extérieur de la classe, de sorte qu'il soit facilement accessible aux autres classes de cet espace de noms, comme ci-dessous.
namespace UserManagement
{
public enum UserStatus { Active, InActive }
class User
{
...
}
}
En général, je préfère que mes enums soient dans le même fichier que la classe dont il sera très probablement un attribut. Si, par exemple, j'ai une classe Task, l'énumération TaskStatus sera dans le même fichier.
Cependant, si j'ai des énumérations de nature plus générique, je les conserve contextuellement dans différents fichiers.
Cela dépend de quel accès est nécessaire.
Si l'énumération n'est utilisée que par une seule classe, vous pouvez la déclarer dans cette classe, car vous n'avez pas besoin de l'utiliser ailleurs.
Pour les énumérations utilisées par plusieurs classes ou dans une API publique, je conserverai toujours la définition dans son propre fichier, dans l'espace de noms approprié. C'est beaucoup plus facile à trouver, et la stratégie suit le modèle d'un objet par fichier, ce qui est également utile pour les classes et les interfaces.
Je pense que cela dépend de la portée de l'énum. Par exemple, si l'énumération est spécifique à une classe, par exemple utilisée pour éviter le scénario de la constante magique, je dirais alors de la placer dans le même fichier que la classe:
enum SearchType { Forward, Reverse }
Si l'énumération est générale et peut être utilisée par plusieurs classes pour différents scénarios, alors je serais enclin à l'utiliser dans son propre fichier. Par exemple, le ci-dessous pourrait être utilisé à plusieurs fins:
enum Result { Success, Error }
J'ai tendance à mettre des enums dans leur propre fichier pour une raison très simple: comme pour les classes et les structs, il est agréable de savoir exactement où chercher si vous voulez trouver la définition d'un type: dans le fichier du même nom. (Pour être juste, en VS, vous pouvez toujours utiliser "Aller à la définition" aussi.)
Évidemment, cela peut devenir incontrôlable. Un collègue où je travaille crée même des fichiers séparés pour les délégués.
Si vous utilisez le complément USysWare File Browser pour Visual Studio, vous pouvez très rapidement rechercher des fichiers portant des noms particuliers dans votre solution. Imaginez que vous recherchiez une énumération qui ne se trouve pas dans son propre fichier, mais qui est enterrée dans un fichier dans une solution gigantesque.
Peu importe les petites solutions, mais pour les grandes, il est d'autant plus important de conserver les classes et les enums dans leurs propres fichiers. Vous pouvez les trouver rapidement, les éditer, etc. Je recommande fortement, fortement de mettre votre enum dans son propre fichier.
Et comme il a été dit ... Combien de temps un fichier qui finit par ne représenter que quelques ko est inutile?
L'un des avantages de l'utilisation d'un fichier distinct pour les énumérations est que vous pouvez supprimer la classe d'origine qui utilisait l'énum et écrire une nouvelle classe à l'aide de cette énumération.
Si l'énumération est indépendante de la classe d'origine, son insertion dans un fichier séparé facilite les modifications futures.
Très simple avantage énorme de séparer le fichier. Lorsqu'un objet se trouve dans son propre fichier MyObjectName.cs ... vous pouvez accéder à l'explorateur de solutions, taper MyObjectName.cs et afficher exactement un fichier. Tout ce qui améliore le débogage est agréable.
Un autre avantage sur une note similaire, si vous recherchez tous les fichiers (ctrl+shft+F) pour un nom, vous pouvez trouver 20 références au nom dans le même fichier ... et ce nom trouvé fera partie de différents objets. Dans la fenêtre Résultats de la recherche, tout ce que vous pouvez voir est le numéro de ligne et le nom du fichier. Vous devez ouvrir le fichier et faire défiler pour déterminer l'objet dans lequel se trouve la référence trouvée.
Tout ce qui facilite le débogage, j'aime bien.
J'aime avoir un fichier d'énums public nommé E contenant chaque enum séparé, puis n'importe quel enum peut être consulté avec E ... et ils se trouvent dans un emplacement unique à gérer.
Si vous avez plusieurs projets dans une solution. Mieux vaut alors créer un autre projet Utilities. Créez ensuite un dossier \Enumerations Et créez un static class Imbriqué. Et ensuite, assignez chaque classe statique dans laquelle vous allez créer une énumération qui correspond au nom de vos projets. Par exemple, vous avez un projet nommé DatabaseReader et DatabaseUsers, puis vous pouvez nommer la classe statique comme suit:
public static class EnumUtility {
#region --Database Readers Enum
public static class EnumDBReader {
public enum Actions { Create, Retrieve, Update, Delete};
}
#endregion
#region --Database Users Enum
public static class EnumDBUsers {
public enum UserIdentity { user, admin };
}
#endregion
}
Ensuite, une énumération complète pouvant être utilisée dans l’ensemble des solutions sera déclarée par projet. Utilisez #region pour séparer chaque problème. En cela, il est plus facile de rechercher des enums