Si un Enum commencer par un 0 ou un 1?

Imaginer je l'ai défini l'Enum ci-dessous:

public enum Status : byte
{
    Inactive = 1,
    Active = 2,
}

Quelle est la meilleure pratique à utiliser enum? Faut-il commencer avec 1 comme l'exemple ci-dessus, ou de démarrer avec 0 (sans les valeurs explicites) comme ceci:

public enum Status : byte
{
    Inactive,
    Active
}

Avez-vous vraiment besoin de nombre explicitement à tous?
Les énumérations ont été créés juste pour que ce genre de choses ne serait pas important.
pourquoi ne pas utiliser un booléen?
arrgh pas! Mieux utiliser un enum lorsque vous pense est un booléen va faire que d'utiliser un booléen quand vous pensez à un enum.
en raison de la FileNotFound de valeur, bien sûr
stackoverflow.com/questions/1240739/...
Je suis d'accord que la question est liée à ce problème (même si c'est spécifiquement sur les paramètres de la fonction), mais je pense qu'il y a également de solides arguments contre l'utilisation de booléen pour les membres / les variables dans de nombreux cas. Il y a de les choses qui véritablement ne disposez que de 2 membres et n'aura jamais un 3ème, mais une fois que vous obtenez à partir du "monde réel" dans le logiciel de domaine, ils sont en fait assez rare, sauf pour calculé les conditions (pour qui les booléens sont bien sûr exactement).
Type de sécurité est une autre considération.
xkcd.com/163 s'applique à l'enum de même mieux que de les indices de tableau.
Que XKCD s'applique à cette façon 🙂 C'est assez absurde...
vous ne devez jamais utiliser un boolean pour quelque chose qui n'est pas en soi un "oui" ou " non " à la question, même si elle n'a que deux valeurs possibles. Côté de considérer qu'il peut ajouter un autre Statut de la semaine prochaine appelé "l'Attente", etc., il vient de rendre le code plus lisible et compréhensible pour les humains. -- (Juste parce que vous pouvez activer quelque chose dans un "oui" ou " non " à la question ne signifie pas que vous devriez. - Si quelqu'un vous demande votre statut, vous ne pouvez pas dire "oui".)
Oui je recommanderais numérotation des enums explicitement. La raison en est que toute réorganisation de l'énumération des éléments de changer leurs valeur. Maintenant, si vous stocker ces valeurs dans une base de données, les données ne seront pas synchronisées avec le code. Si ils sont explicites, le re-commande de ne pas changer leurs valeurs.
pas vrai. Les valeurs sont importantes, ils ont été créés de sorte que vous pouvez avoir des collections de valeurs significatives, sans avoir à disputer quelques consts ensemble et de créer l'association vous-même. Pas de départ à 0 est un bon moyen d'établir qu'ils doivent être explicitement définis et de prévenir les erreurs où une valeur non semble être intentionnellement.

InformationsquelleAutor Acaz Souza | 2011-08-31

.net c#enums

152

Cadre Des Lignes Directrices De Conception:
- Ne fournir une valeur de zéro sur votre non-drapeaux de l'enum
  Si Aucun ne convient pas pour les enum, puis affectez-lui la valeur zéro de l'élément qui
  doit être utilisé comme valeur par défaut pour le protocole enum.
- Éviter à l'aide de drapeau des valeurs enum normale membres qui sont négatifs ou
  zéro. .. Un enum valeur de zéro crée des problèmes avec et
  des opérations, etc
- L'échec précoce: Si "Aucun" n'est pas approprié, mais il n'y a pas de logique de valeur par défaut, j'aurais quand même mis une valeur de zéro (et de l'appeler 'None' ou 'Invalide') qui n'est pas destiné à être utilisé, juste pour que si un membre de la classe de cette énumération n'est pas initialisé correctement, la valeur non initialisée peut facilement être repéré, et dans switch les déclarations qu'il va passer à la default l'article, où je jette un InvalidEnumArgumentException. Sinon, un programme peut-être involontairement continuer à fonctionner avec le zéro de la valeur d'une énumération, qui peut être valable et passer inaperçu.
- Il semble préférable de donner uniquement les valeurs enum vous savez qu'ils sont valides, puis de vérifier les valeurs non valides dans l'incubateur et/ou d'un constructeur. De cette façon, vous savez immédiatement si un code ne fonctionne pas correctement, plutôt que de permettre à un objet avec des données invalides à exister pour quelques temps inconnu et de la découverte de la plus tard. Sauf si "Aucun" représente un état valide, vous ne devriez pas l'utiliser.
- Qui sonne comme un cas où vous n'oubliez pas d'initialiser un enum membre de la classe dans un constructeur. Aucun montant de la validation de vous aider si vous avez oublié d'initialiser ou oubliez pas de le valider. Aussi, il y a simple DTO classes qui n'ont pas de constructeurs, mais s'appuyer sur les initialiseurs d'objets à la place. La chasse de ce bug peut être extrêmement douloureux. Néanmoins, l'ajout d'une nouvelle valeur de l'énumération rend laid API. Je voudrais l'éviter pour les Api orientée pour la consommation publique.
- C'est un bon point, mais je dirais que vous devriez être à la validation des énumérations dans la fonction de définition et jetant à partir de la lecture si le compositeur n'a jamais été appelé. De cette façon, vous avez un point de défaillance et vous pouvez planifier sur le champ de toujours avoir une valeur valide, ce qui simplifie la conception et le code. Mes deux cents, de toute façon.
- Imaginez un DTO classe avec 15 propriétés implémentées automatiquement. Son corps est de 15 lignes de long. Maintenant, imaginez la même classe avec des propriétés. C'est un minimum de 180 lignes avant de les ajouter à toute vérification de la logique. Cette classe est utilisée exclusivement à l'interne pour le transfert de données seulement. Lequel préférez-vous, un 15 ligne ou une catégorie d'180+ lignes de classe? La concision a sa valeur. Mais toujours est-il que nos styles sont corrects, ils sont simplement différents. (Je suppose que c'est là AOP balayages et les victoires des deux côtés de l'argument).
- Mais lorsqu'il n'est pas à l'aide de valeurs à 0 pour les enums je rencontre "Une exception de type 'System.NullReferenceException' s'est produite dans MyProjectName.dll mais n'a pas été traitée dans le code utilisateur. Informations supplémentaires: Objet de référence non définie à une instance d'un objet." erreur. Comment résoudre ce problème? Remarque: j'utilise une méthode d'extension pour afficher l'enum Descriptions, mais vous ne savez pas comment faire pour éviter l'erreur dans la méthode d'assistance (GetDescription) définie sur cette page
- Si vous permettez que pas de drapeaux ont été mis sur vos drapeaux, enum, vous devriez totalement ajouter un None = 0 en haut; Vous pouvez faire le début abandonne dans votre code de cette façon (c'est à dire if (value == MyFlags.None) { return; }, etc.)
InformationsquelleAutor Andrey Taptunov
62

Bien, je suppose que je suis en désaccord avec la plupart des réponses qui disent pas explicitement nombre d'eux. J'ai toujours explicitement nombre, mais c'est parce que dans la plupart des cas, j'arrive à la fin de persistance dans un flux de données où elles sont stockées sous forme d'une valeur entière. Si vous n'avez pas ajouter explicitement les valeurs et ensuite ajouter une nouvelle valeur que vous pouvez briser la sérialisation et puis ne pas être en mesure de charger des vieux objets persistants. Si vous allez faire n'importe quel type de magasin persistant de ces valeurs, alors je vous recommande fortement de définir explicitement les valeurs.
- +1, d'accord, mais seulement dans le cas où votre code s'appuie sur l'entier pour certains une raison externe (par exemple. sérialisation). Partout ailleurs, vous devriez coller avec juste laisser le cadre de la faire son travail. Si vous comptez sur les valeurs entières en interne, alors vous avez probablement fait quelque chose de mal (voir: que le cadre ne c'est du boulot).
- Bon point, +1!
- Je suis totalement d'accord. Dans beaucoup de code que j'ai écris, je suis la sérialisation de disque ou une base de données, j'ai donc tendance à persister la valeur de l'entier, et donc les valeurs qui doivent être définies de manière explicite. Si l'enum est jamais persisté, puis j'ai laissé le système de définir les valeurs. Comme vous l'avez dit, si vous êtes en utilisant les valeurs de type entier à des fins de comparaison dans le code, alors vous faites quelque chose de mal.
- Je tiens à conserver le texte de l'enum. Rend la base de données beaucoup plus utilisable de l'omi.
- Normalement, vous n'avez pas besoin de définir explicitement les valeurs... même lorsqu'ils être sérialisé. il suffit de ne TOUJOURS ajouter de nouvelles valeurs à la fin. cela permettra de résoudre la sérialisation des problèmes. sinon, vous pourriez avoir besoin d'une gestion des versions de votre magasin de données (par exemple, un fichier d'en-tête contenant une version pour le changement de comportement lors de la lecture/écriture de valeurs) (ou voir memento modèle)
- Stegi: Parfois, il peut y avoir une séquence logique pour une énumération (par exemple, les états d'une machine d'état), et il serait logique d'ajouter de nouveaux états dans l'ailleurs de la fin. Par exemple, une machine à états "Init WaitForData ReadingData GotData" pourriez avoir besoin d'avoir un "DiscardInitialJunk" etat ajouté entre "WaitForData" et "ReadingData". Si les valeurs d'état ne sera pas persisté entre le code reconstruit, le nouvel état doit être inséré dans son séquentielle spot (changer plus tard des valeurs). Si les valeurs sont conservées entre versions, cependant, ceux qui, plus tard des valeurs ne doit pas changer.
- À moins que vous expliclty document enum sont des textes sacrés, vous définissez vous-même à l'échec, si un programmeur décide d'adapter un nom pour être plus clair ou de se conformer à certaines conventions de nommage.
- supercat fait un bon point si le nom de l'énumération des changements, c'est aussi moins d'espace dans la base de données/fichier persistant si vous êtes à la persistance d'un int vs chaîne. L'autre domaine, ne sont pas mentionnés seraient streaming sur certains de connexion de socket/service WCF, etc. Dans ce cas, j'ai vraiment envie de flux de l'int et non pas la chaîne pour couper la circulation.
- Où je travaille, nous avons généralement sérialiser à des fichiers de texte, enum noms sont conservés. Si l'option de changement de valeur il n'y a pas de problème la plupart du temps. Dans une poignée de cas, nous avons besoin de sérialiser pour les fichiers binaires. Dans ce cas, un CRC est généré, et si l'enum est modifié, le CRC changements, et il affirme sur démarrer et se plaint bruyamment jusqu'à ce que la mise en cache de la CRC est mis à jour (ce qui signifie que vous besoin de réexportation tous les fichiers binaires) ou l'enum est revenue.
- Pas si vous avez toute sorte de décent de tests automatisés, j'en suis sûr - c'est un risque, mais il faudrait être pris Si les gardes de sécurité sont en place. Je pense que l'avantage d'avoir "theTextOfEnum14" dans la base de données plutôt que de 14, bien qu' - rend les choses beaucoup plus facile pour en faire rapport, d'interroger et de manière générale, "utilisation".
- c'est un style hors commerce je suppose que l'espace disque est bon marché si, le temps passé en permanence la conversion entre les valeurs de l'enum et un intwhen la recherche de la db est relativement cher (doublement si vous avez une déclaration d'installation de l'outil sur une base de données ou quelque chose de similaire). Si vous êtes inquiet abotu de l'espace, avec les nouvelles versions de SQL server, vous pouvez avoir une base de données compressées, ce qui signifie 1000 occurrences de "SomeEnumTextualValue" utilisera à peine plus de place. Bien sûr, cela ne fonctionne pas pour tous les projets - c'est hors commerce. Je pense que le souci au sujet de la bande passante sent l'optimisation prématurée, peut-être!
- vous ne savez pas faire la conversion à partir d'un enum pour un int est cher, vous pouvez simplement le jeter, il n'y a pas de véritable conversion qui doit arriver. Si je suis en cours d'exécution d'une requête qui est réservé à certains valeur d'enum, je jette la enum pour un int et l'ajouter à la chaîne. Si je suis à l'analyse des lignes qui vient de sortir, encore une fois, je peux tout simplement jeté l'int de l'enum. Si je suis la persistance de la valeur d'enum comme une chaîne de caractères, puis-je avoir à payer une pénalité pour convertir les enum à la chaîne et de la chaîne d'enum.
- Je veux dire hors de code lors de la recherche de la DB '1' signifie rien, mais "Actif" est lisible (encore plus vrai lorsque l'on travaille avec beaucoup de grandes enums!). Cela est également vrai si vous avez un ETL ou de l'outil de reporting en cours d'utilisation - le texte est utilisable (Active) plutôt que de '1'. La seule façon de contourner cela est d'avoir plusieurs points de changement... Aussi, si je swap enum commandes ou de modifier les valeurs (sans définir explicitement un int valeur à chaque enum) je peut facilement introduire des stupides erreurs lors de la persistance d'un int.
- bon, maintenant je suivre où que vous alliez (doit avoir été plus clair pour moi depuis que vous avez mentionné explicitement reporting). Dans le cas où j'ai été la persistance des enums, j'ai en général pas eu à se soucier d'un utilisateur sous forme déchiffrable, et donc n'ont jamais vraiment réfléchi à cette question. Je persiste choses pour notre logiciel à utiliser. La valeur est conservée et extrait de notre code. Je pense que je serais toujours en fin de persistance comme un int et de la traduire, mais je suis d'accord que c'est un style de chose, et je pense que je pourrais être convaincu de le faire d'une autre manière en fonction de conception globale.
- Oui - je suis d'accord c'est un choix stylistiques, et peut-être d'architecture, en fonction de l'application - c'est agréable de voir les deux méthodes, en particulier les forces et les faiblesses.
- sûrement enum noms sont déjà sacré, en passant par l'esprit de l'enum? Si jamais j'ai envie/besoin de changer les noms enum je m'attends à être extrêmement prudent et diligent dans la recherche et les tests de tous les effets secondaires, - un nom est pour la vie, pas seulement pour noël ;).
- Ce qui est important, c'est que la corrélation entre le nom et la valeur de durer aussi longtemps que tout ce qui s'appuie sur elle. Les choses qui sont publiques devraient être immortel, comme le sont les choses qui sont conservées dans une mémoire externe. Si un enum est ni, alors le code qui pourrait s'appuyer sur sa valeur de séquence sera dans une seule assemblée. Modification d'une valeur d'énumération serait alors sûr que si, et seulement si, tout le code de cette assemblée peut gérer le changement.
- Vous devriez sérialiser comme des chaînes de caractères. Mais je vous entends, parfois vous n'avez pas le choix (c'est à dire hérité de la base de code, d'une compatibilité ascendante, etc.) - mais de toute façon, assurez-vous que lorsque vous utilisez un [Flags] enum que lorsque vous affectez les valeurs que vous le faire par des puissances de deux, au lieu de simplement incrémenter eux.
InformationsquelleAutor pstrjds
14

Une énumération est un type de valeur et sa valeur par défaut (par exemple pour un champ Enum dans une classe) sera 0 si non initialisé explicitement.

Donc en général, vous voulez avoir 0 comme une constante définie (par exemple, Inconnue).

Dans votre exemple, si vous voulez Inactive par défaut, il devrait avoir la valeur zéro. Sinon, vous pourriez envisager l'ajout d'une constante Unknown.

Certaines personnes ont recommandé de ne pas spécifier explicitement des valeurs constantes. Sans doute de bons conseils dans la plupart des cas, mais il y a certains cas où vous voulez le faire:
- Drapeaux des enums
- Les énumérations dont les valeurs sont utilisées dans l'interopérabilité avec les systèmes externes (p. ex. COM).
- J'ai trouvé que les drapeaux des enums sont beaucoup plus lisible lorsque vous ne pas définir explicitement les valeurs. -- Aussi moins enclins à faire des erreurs pour permettre au compilateur de faire les mathématiques binaires pour vous. (c'est à dire [Flags] enum MyFlags { None = 0, A, B, Both = A | B, /* etc. */ }, c'est bien plus lisible, que [Flags] enum MyFlags { None = 0, A = 1, B = 2, Both = 3, /* etc */ }.)
- Je ne vois pas comment cela pourrait être utile dans le cas général - par exemple, [Flags] enum MyFlags { None=0, A, B, C } entraînerait [Flags] enum MyFlags { None=0, A=1, B=2, C=3 }, alors que, pour les Drapeaux enum vous souhaitez généralement C=4.
InformationsquelleAutor Joe
14

Sauf si vous avez une raison particulière de le changer, de laisser les énumérations avec leurs valeurs par défaut, qui commence à zéro.
```
public enum Status : byte
{
    Inactive,
    Active
}
```
InformationsquelleAutor FishBasketGordo
5

Je dirais que la meilleure pratique est de pas qu'elle soit implicite - qui commence à partir de 0. Depuis sa implicite ses la préférence de langue qui est toujours bon à suivre 🙂

InformationsquelleAutor John Humphreys - w00te
5

Je voudrais commencer un booléen de type enum avec un 0.

Sauf si "Inative" signifie autre chose que "Inactif" 🙂

Il conserve la norme pour ceux.

InformationsquelleAutor Mark Schultheiss
5

Je dirais, ça dépend de comment vous les utilisez. À des fins de repérage enum c'est une bonne pratique d'avoir 0 pour None valeur, comme ça:
```
[Flags]
enum MyEnum
{
    None = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    All = Option1 | Option2 | Option3,
}
```
Lorsque votre enum est susceptible d'être relié à une base de données de la table de recherche, j'aimerais commencer avec 1. Il ne devrait pas avoir beaucoup d'importance pour professionnellement code écrit, mais cela augmente la lisibilité.

Dans d'autres cas, je préfère le laisser tel qu'il est, sans donner les soins qu'ils commencent par 0 ou 1.

InformationsquelleAutor Michael Sagalovich
4

Sauf si vous avez une bonne raison pour utiliser les valeurs brutes, vous ne devriez jamais être à l'aide de valeurs implicites et de référencement avec Status.Active et Status.Inactive.

Le hic, c'est que vous pourriez vouloir stocker des données dans un fichier plat ou DB, ou de l'utilisation d'un fichier plat ou DB que quelqu'un d'autre a créé. Si vous réalisez vous-même, faire en sorte que la numérotation correspond à ce que l'Enum est utilisé pour.

Si les données n'est pas la vôtre, bien sûr, vous allez vouloir l'utiliser quelle que soit l'origine dev avait utilisé comme un système de numérotation.

Si vous prévoyez sur l'utilisation de l'énumération que d'un jeu d'indicateurs, il est une simple convention qui en vaut la suivante:
```
enum Example
{
  None      = 0,            // 0
  Alpha     = 1 << 0,       // 1
  Beta      = 1 << 1,       // 2
  Gamma     = 1 << 2,       // 4
  Delta     = 1 << 3,       // 8
  Epsilon   = 1 << 4,       //16
  All       = ~0,           //-1
  AlphaBeta = Alpha | Beta, // 3
}
```
Les valeurs doivent être des puissances de deux et peut être exprimée à l'aide de décalage de bit opérations. None, évidemment devrait être 0, mais All est moins évidemment -1. ~0 est la négation binaire de 0 et les résultats dans un numéro qui a tous les bits mis à 1, ce qui représente une valeur de -1. Pour la composition de drapeaux (souvent utilisé pour des raisons de commodité) d'autres valeurs peuvent être fusionnés à l'aide de l'opérateur or |.

InformationsquelleAutor zzzzBov
2

N'attribuez pas des numéros.
Juste l'utiliser comme il doit être utilisé.

InformationsquelleAutor Hooch
2

Si vous commencer à 1, alors vous pouvez facilement obtenir un nombre de choses.
```
{
    BOX_THING1     = 1,
    BOX_THING2     = 2,
    BOX_NUM_THING  = BOX_THING2
};
```
Si vous commencez à 0, puis d'utiliser la première comme une valeur non initialisée choses.
```
{
    BOX_NO_THING   = 0,
    BOX_THING1     = 1,
    BOX_THING2     = 2,
    BOX_NUM_THING  = BOX_THING2
};
```
- Désolé, Jonathan. Je pense que, cette suggestion est un peu "old school" dans ma tête (un genre de convention vient de bas-niveau c-années). C'est ok comme une solution rapide à "intégrer" certains supplémentaire d'infos sur les enum, mais ce n'est pas une bonne pratique dans de plus grands systèmes. Vous ne devriez pas utiliser un enum si vous avez besoin d'info sur le nombre de valeurs disponibles etc. Et à propos d'une BOX_NO_THING1? Voulez-vous lui donner BOX_NO_THING+1? Les Enums doit être utilisé que par ce qu'ils sont destinés à être utilisés pour: Spécifique (int), les valeurs représentées par le "parler" des noms.
- Hm. Vous êtes en supposant que c'est de la vieille école parce que j'ai utilisé tous les chapeaux, je suppose, plutôt que de MicrosoftBumpyCaseWithLongNames. Même si je suis d'accord qu'il est préférable d'utiliser des itérateurs de la boucle jusqu'à atteindre un enum ed XyzNumDefsInMyEnum définition.
- ancien de l'école des roches 🙂
- C'est terrible pratique en C# dans une variété de façons. Maintenant, quand vous allez obtenir un décompte de vos énumérations, de la bonne façon, ou si vous tentez de les énumérer la bonne façon, vous obtiendrez un supplément, copie de l'objet. Il fait également le .ToString() appel potentiellement ambigu (vissage moderne de sérialisation), entre autres choses.
InformationsquelleAutor Jonathan Cline IEEE
2

Si non spécifiée, la numérotation commence à 0.

Il est important d'être explicite depuis les énumérations sont souvent sérialisé et stocké dans un int, pas une chaîne de caractères.

Pour tout enum stockées dans la base de données, nous avons toujours explicitement nombre les options permettant de prévenir les déplacements et la réaffectation au cours de l'entretien.

Selon Microsoft, la convention est d'utiliser la première option zéro pour représenter un non initialisée ou la plus commune de la valeur par défaut.

Ci-dessous est un raccourci pour démarrer la numérotation à 1 au lieu de 0.
```
public enum Status : byte
{
    Inactive = 1,
    Active
}
```
Si vous souhaitez définir des valeurs d'indicateur afin d'utiliser les bits les opérateurs sur les valeurs de l'enum, ne pas commencer la numérotation à la valeur zéro.

InformationsquelleAutor dru
0

Tout d'abord, sauf si vous spécifiez des valeurs spécifiques pour une raison (la valeur numérique a de sens que quelque part d'autre, c'est à dire La Base de données ou de services externes), puis ne pas spécifier des valeurs numériques à tous les et laissez-les être explicite.

Deuxième de tous, vous devriez toujours avoir une valeur de zéro (en non-drapeaux des enums). Cet élément sera utilisé comme valeur par défaut.

InformationsquelleAutor Justin Niessner
0

Ne commence pas à 0, sauf si il y a une raison, comme les utilisant comme des indices d'un tableau ou d'une liste, ou s'il y a une autre raison pratique (comme l'utilisation dans des opérations bit à bit).

Votre enum devrait commencer exactement là où il faut. Il n'a pas besoin d'être séquentielle, soit. Les valeurs, si elles sont explicitement définies, doivent tenir compte de certaines de sens sémantique ou des considérations d'ordre pratique. Par exemple, un enum des "bouteilles sur le mur" doivent être numérotés de 1 à 99, tandis qu'un enum pour des puissances de 4 devrait probablement commencer à 4 et continuer avec 16, 64, 256, etc.

En outre, l'ajout d'une valeur zéro de l'élément à la enum doit uniquement être effectuée si elle représente un état valide. Parfois, "aucun", "inconnu", "manque", etc. sont des valeurs valides, mais de nombreuses fois ils ne le sont pas.

InformationsquelleAutor wprl
-1

Je voudrais commencer ma enums à 0, puisque c'est la valeur par défaut, mais j'aime aussi inclure une valeur Inconnue, avec une valeur de -1. Cela devient alors la valeur par défaut et peut aider au débogage parfois.
- Idée Horrible. Comme un type de valeur, les énumérations sont toujours initialisées à zéro. Si vous allez avoir une certaine valeur qui représente inconnu ou non initialisée, elle doit être à 0. Vous ne pouvez pas modifier la valeur par défaut -1, zéro de remplissage est codé en dur tout au long de la CLR.
- Ah, je ne savais pas que. De manière générale, j'définir la valeur d'une valeur d'énumération et de la propriété quand je decalre/initialiser. Merci pour le pointeur.
InformationsquelleAutor Tomas McGuinness

Vous devez vous connecter pour publier un commentaire.