Les énumérations en C # doivent-elles avoir leur propre fichier? [fermé]

J'ai une classe qui utilise une énumération, l'énumération est actuellement dans son propre fichier, ce qui semble inutile.

Quelle est l'opinion générale sur les énumérations placées dans l'espace de noms d'un fichier dans lequel elles sont consommées? Ou l'énumération devrait-elle vraiment vivre dans son propre fichier cs?

Éditer

Je dois mentionner que si la classe en question utilise ces énumérations, il en va de même pour les appelants externes. En d'autres termes, une autre classe peut définir ces énumérations. Donc, ils ne sont pas utilisés en interne à la classe, sinon cette question serait une évidence.

Je ne dirais pas «gaspillage» (combien coûte un fichier supplémentaire?), Mais c'est souvent gênant. Habituellement, il y a une classe qui est la plus étroitement associée à l'énumération, et je les mets dans le même fichier.

C'est vraiment juste une question de préférence.

Je préfère mettre chaque énumération dans son propre fichier (de même pour chaque interface, classe et structure, aussi petite soit-elle). Cela les rend plus faciles à trouver lorsque je viens d'une autre solution ou que je n'ai pas déjà de référence au type en question.

Le fait de placer un seul type dans chaque fichier facilite également l'identification des changements dans les systèmes de contrôle de source sans faire de différence.

C'est entièrement une question de style. Ce que j'ai tendance à faire est d'avoir un fichier appelé Enums.csdans la solution dans lequel les déclarations d'énumération sont collectées.

Mais ils se trouvent généralement à travers la F12clé de toute façon.

La question à se poser serait: y a-t-il quelque chose à propos d'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 comme 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 que ce soit un type public est tout ce qui compte; la saveur du type ne l'est pas.

Un autre avantage de placer chaque type (class, struct, enum) dans son propre fichier est le contrôle de code source. Vous pouvez facilement obtenir l'historique complet du type.

Je place principalement à l'intérieur dans l'espace de noms et à l'extérieur de la classe afin qu'il soit facilement accessible aux autres classes dans 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 énumérations soient dans le même fichier que la classe dont ce sera probablement un attribut. Si par exemple j'ai une classe Taskalors l'énumération TaskStatussera dans le même fichier.

Cependant, si j'ai des énumérations de nature plus générique, je les garde contextuellement dans divers fichiers.

Cela dépend de l'accès 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 de cette façon, et la stratégie suit le modèle d'un objet par fichier, ce qui est également bon à utiliser avec les classes et les interfaces.

Je pense que cela dépend de la portée de l'énumération. Par exemple, si l'énumération est spécifique à une classe, par exemple utilisée pour éviter le scénario de constante magique, alors je dirais de la mettre 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, ce qui suit pourrait être utilisé à plusieurs fins:

enum Result { Success, Error }

J'ai tendance à mettre enums dans leur propre fichier pour une raison très simple: comme pour les classes et les structs, c'est bien de savoir exactement où chercher si vous voulez trouver la définition d'un type: dans le fichier du même nom. (Pour être honnête, dans VS, vous pouvez toujours utiliser "Aller à la définition".)

É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.

L'un des avantages de l'utilisation d'un fichier séparé pour les énumérations est que vous pouvez supprimer la classe d'origine qui a utilisé l'énumération et écrire une nouvelle classe à l'aide de l'énumération.

Si l'énumération est indépendante de la classe d'origine, la placer dans un fichier séparé facilite les modifications futures.

Si vous utilisez le complément du navigateur de fichiers USysWare pour Visual Studio, vous pouvez trouver très rapidement des fichiers de noms particuliers dans votre solution. Imaginez que vous cherchiez une énumération qui ne soit pas dans son propre fichier mais plutôt enterrée dans un fichier dans une solution gigantesque.

Pour les petites solutions, cela n'a pas d'importance, mais pour les grandes, il devient d'autant plus important de conserver les classes et les énumérations dans leurs propres fichiers. Vous pouvez les trouver rapidement, les modifier, etc. Je recommande vivement de mettre votre enum dans son propre fichier.

Et comme cela a été dit ... Quel gaspillage est un fichier qui ne fait que quelques Ko de toute façon?

Très simple avantage énorme pour séparer le fichier. Lorsqu'un objet est dans son propre fichier MyObjectName.cs ... vous pouvez accéder à l'explorateur de solutions et taper MyObjectName.cs et afficher exactement 1 fichier. Tout ce qui améliore le débogage est bien.

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 d'objets différents. 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 devrez ouvrir le fichier et faire défiler pour déterminer dans quel objet se trouvait la référence trouvée.

Tout ce qui facilite le débogage, j'aime.

Si vous avez plusieurs projets dans une seule solution. Alors mieux vaut créer un autre projet Utilities. Ensuite, créez un dossier \Enumerationset créez un fichier imbriqué static class. Et puis attribuez chaque classe statique où vous allez créer une énumération qui correspond au nom de vos projets. Par exemple, vous avez un projet nommé DatabaseReader et DatabaseUsers, vous pouvez nommer la classe statique comme

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, toute l'énumération qui peut être utilisée dans l'ensemble des solutions par projets sera déclarée dessus. Utilisez # regionpour séparer chaque préoccupation. Grâce à cela, il est plus facile de rechercher des énumérations

J'aime avoir un fichier d'énumérations public nommé E contenant chaque énumération séparée, puis toute énumération peut être accédée avec E ... et ils sont dans un seul endroit à gérer.