Un Enum doit-il commencer par un 0 ou un 1?

Imaginez que j'ai défini l'énumération suivante:

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

Quelle est la meilleure pratique pour utiliser enum? Devrait-il commencer par 1comme l'exemple ci-dessus ou commencer par 0(sans les valeurs explicites) comme ceci:

public enum Status : byte
{
    Inactive,
    Active
}

Directives de conception du cadre :

✔️ Fournissez une valeur de zéro sur les énumérations simples.

Pensez à appeler la valeur quelque chose comme "Aucun". Si une telle valeur n'est pas appropriée pour cette énumération particulière, la valeur par défaut la plus courante pour l'énumération doit être affectée à la valeur sous-jacente de zéro.

Directives de conception de cadre / conception d'énumérations d'indicateur :

❌ ÉVITEZ d'utiliser des valeurs d'énumération d'indicateur de zéro à moins que la valeur ne représente «tous les indicateurs sont effacés» et qu'elle soit nommée de manière appropriée, comme prescrit par la ligne directrice suivante.

✔️ Nommez la valeur zéro des énumérations d'indicateur None. Pour une énumération d'indicateur, la valeur doit toujours signifier «tous les indicateurs sont effacés».

Eh bien, je suppose que je ne suis pas d'accord avec la plupart des réponses qui disent de ne pas les numéroter explicitement. Je les numérote toujours explicitement, mais c'est parce que dans la plupart des cas, je finis par les conserver dans un flux de données où ils sont stockés sous forme de valeur entière. Si vous n'ajoutez pas explicitement les valeurs, puis ajoutez une nouvelle valeur, vous pouvez interrompre la sérialisation et ne pas pouvoir charger avec précision les anciens objets persistants. Si vous envisagez de faire un type de stockage persistant de ces valeurs, je vous recommande vivement de définir explicitement les valeurs.

Un Enum est un type valeur et sa valeur par défaut (par exemple pour un champ Enum dans une classe) sera 0 si elle n'est pas initialisée explicitement.

Par conséquent, vous voulez généralement avoir 0 comme constante définie (par exemple, Inconnu).

Dans votre exemple, si vous voulez Inactiveêtre la valeur par défaut, il doit avoir la valeur zéro. Sinon, vous pouvez envisager d'ajouter une constante Unknown.

Certaines personnes ont recommandé de ne pas spécifier explicitement les valeurs de vos constantes. Probablement un bon conseil dans la plupart des cas, mais il y a des cas où vous voudrez le faire:

• Énumérations des drapeaux

• Énumérations dont les valeurs sont utilisées en interopérabilité avec des systèmes externes (par exemple COM).

Sauf si vous avez une raison spécifique de le modifier, laissez les énumérations avec leurs valeurs par défaut, qui commencent à zéro.

public enum Status : byte
{
    Inactive,
    Active
}

Je dirais que la meilleure pratique est de ne pas les numéroter et de le laisser être implicite - ce qui commencerait à partir de 0. Puisque c'est implicite, c'est la préférence de langue qui est toujours bonne à suivre :)

Je commencerais une énumération de type booléen avec un 0.

Sauf si "Inatif" signifie autre chose que "Inactif" :)

Cela conserve la norme pour ceux-ci.

Je dirais que cela dépend de la façon dont vous les utilisez. Pour marquer enum, il est recommandé d'avoir 0 pour Nonevaleur, comme ça:

[Flags]
enum MyEnum
{
    None = 0,
    Option1 = 1,
    Option2 = 2,
    Option3 = 4,
    All = Option1 | Option2 | Option3,
}

Lorsque votre énumération est susceptible d'être mappée à une table de recherche de base de données, je la commencerais par 1. Cela ne devrait pas avoir beaucoup d'importance pour le code écrit par des professionnels, mais cela améliore la lisibilité.

Dans d'autres cas, je le laisserais tel quel, sans me soucier de savoir s'ils commencent par 0 ou 1.

À moins que vous n'ayez une bonne raison d'utiliser les valeurs brutes, vous ne devriez jamais utiliser que des valeurs implicites et les référencer avec Status.Activeet Status.Inactive.

Le problème est que vous souhaiterez peut-être stocker des données dans un fichier plat ou une base de données, ou utiliser un fichier plat ou une base de données créé par quelqu'un d'autre. Si vous le faites vous-même, faites en sorte que la numérotation corresponde à l'utilisation de Enum.

Si les données ne vous appartiennent pas, bien sûr, vous voudrez utiliser tout ce que le développeur d'origine avait utilisé comme schéma de numérotation.

Si vous prévoyez d'utiliser Enum comme un ensemble d'indicateurs, il existe une convention simple qui vaut la peine d'être suivie:

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 peuvent être exprimées à l'aide d'opérations de décalage de bits. None, devrait évidemment être 0, mais Allest moins évident -1. ~0est la négation binaire de 0et donne un nombre dont chaque bit est défini sur 1, ce qui représente une valeur de-1 . Pour les indicateurs composés (souvent utilisés pour des raisons de commodité), d'autres valeurs peuvent être fusionnées à l'aide de l'opérateur binaire ou |.

N'attribuez aucun numéro. Utilisez-le simplement comme il est censé être utilisé.

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

Il est important d'être explicite car les énumérations sont souvent sérialisées et stockées sous la forme d'un int, pas d'une chaîne.

Pour toute énumération stockée dans la base de données, nous numérotons toujours explicitement les options pour empêcher le décalage et la réaffectation pendant la maintenance.

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

Vous trouverez ci-dessous un raccourci pour commencer 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 des opérateurs de bits sur les valeurs d'énumération, ne commencez pas la numérotation à la valeur zéro.

Si vous commencez à 1, vous pouvez facilement compter vos affaires.

{
    BOX_THING1     = 1,
    BOX_THING2     = 2,
    BOX_NUM_THING  = BOX_THING2
};

Si vous commencez à 0, utilisez le premier comme valeur pour les choses non initialisées.

{
    BOX_NO_THING   = 0,
    BOX_THING1     = 1,
    BOX_THING2     = 2,
    BOX_NUM_THING  = BOX_THING2
};

Tout d'abord, à moins que vous ne spécifiiez des valeurs spécifiques pour une raison (la valeur numérique a un sens ailleurs, c'est-à-dire la base de données ou un service externe), ne spécifiez pas du tout de valeurs numériques et laissez-les être explicites.

Deuxièmement, vous devriez toujours avoir un élément de valeur zéro (dans les énumérations non-flags). Cet élément sera utilisé comme valeur par défaut.

Ne les démarrez pas à 0 sauf s'il y a une raison de le faire, comme les utiliser comme index dans un tableau ou une liste, ou s'il y a une autre raison pratique (comme les utiliser dans des opérations au niveau du bit).

Votre enumdevrait commencer exactement là où il le faut. Cela n'a pas besoin non plus d'être séquentiel. Les valeurs, si elles sont explicitement définies, doivent refléter une signification sémantique ou une considération pratique. Par exemple, un enumdes "bouteilles sur le mur" doit être numéroté de 1 à 99, tandis qu'un enumpour les puissances de 4 devrait probablement commencer à 4 et continuer avec 16, 64, 256, etc.

De plus, l'ajout d'un élément de valeur zéro au enumne doit être effectué que s'il représente un état valide. Parfois, «aucune», «inconnue», «manquante», etc. sont des valeurs valides, mais souvent elles ne le sont pas.

J'aime commencer mes énumérations à 0, car 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 parfois aider au débogage.