Enums et constantes. Lequel utiliser quand?

Je faisais des lectures sur les énumérations et je les trouve très similaires à la déclaration de constantes. Comment pourrais-je savoir quand utiliser une constante plutôt qu'une énumération ou vice versa. Quels sont certains des avantages de l'utilisation des énumérations?

Utilisez des énumérations lorsque vous souhaitez définir une plage de valeurs que quelque chose peut être. La couleur est un exemple évident comme:

public enum Colour
{
    White,
    Red,
    Blue
}

Ou peut-être un ensemble de choses possibles comme: (Exemple j'ai volé d' ici car je suis paresseux)

[FlagsAttribute]
enum DistributedChannel
{
  None = 0,
  Transacted = 1,
  Queued = 2,
  Encrypted = 4,
  Persisted = 16,
  FaultTolerant = Transacted | Queued | Persisted
}

Les constantes doivent être pour une seule valeur, comme PI. Il n'y a pas de plage de valeurs PI, il y a juste PI.

Les autres points à considérer sont:

• a: Les constantes n'indiquent pas nécessairement une relation entre les constantes, alors qu'une énumération indique que quelque chose peut être l'un de l'ensemble défini par l'énumération.
• b: Une énumération définie peut vous aider à vérifier le type lorsqu'elle est utilisée comme argument. Les constantes ne sont que des valeurs, elles ne fournissent donc aucune information sémantique supplémentaire.

Ce qui manque dans les autres réponses, c'est que les énumérations ont un type de base entier. Vous pouvez changer la valeur par défaut de int en tout autre type intégral sauf char comme:

enum LongEnum : long {
    foo,
    bar,
}

Vous pouvez effectuer un cast explicitement depuis et implicitement vers le type de base, ce qui est utile dans les instructions switch. Attention, on peut convertir n'importe quelle valeur du type de base en une énumération, même si l'énumération n'a pas de membre avec la valeur appropriée. Donc, utiliser toujours la section par défaut dans un commutateur est une bonne idée. BTW, .NET lui-même autorise même les énumérations à valeur en virgule flottante, mais vous ne pouvez pas les définir en C #, même si je pense que vous pouvez toujours les utiliser (sauf dans switch).

De plus, l'utilisation des énumérations vous donne plus de sécurité de type. Si vous avez l'intention d'utiliser par exemple des constantes int comme paramètres de méthode, alors je pourrais appeler la méthode avec n'importe quelle valeur int. Certes, via le casting, cela peut également arriver avec des énumérations, mais cela ne se produira pas accidentellement. Le pire est la possibilité de confondre l'ordre des paramètres.

void method(int a, int b) {...}

Si la constante A seulement peut aller dans a et la constante B seulement peut aller dans b, alors l'utilisation de deux types d'énumération différents découvrira tout abus lors de la compilation.

Une constante est une fonctionnalité de langage qui dit que la variable ne changera pas de valeur (afin que le compilateur puisse faire des optimisations autour de cette connaissance) où une énumération est un type spécifique.

Les constantes peuvent être de n'importe quel type de données, mais une énumération est une énumération.

J'utilise une énumération à tout endroit où vous pourriez avoir un certain nombre d'options et que vous souhaitez améliorer la lisibilité du code. c'est-à-dire que vous pourriez avoir des niveaux de trace comme un int avec des valeurs 0, 1, 2 ou comme une énumération comme erreur, avertissement et info.

Les Enum ont également la capacité d'être utilisés comme opérateurs de bits, c'est-à-dire FontStyle.Bold | FontStyle.Italic vous donnerait des polices en gras et en italique.

En plus de la réponse de Robert:

1. Utilisez enum pour un ensemble fini de valeurs nommées. Vous ne vous souciez pas vraiment de la valeur numérique derrière chaque symbole (mais vous avez toujours la possibilité de les imposer, par exemple pour la compatibilité avec un système hérité).

2. Robert: Oui, les Enum peuvent être utilisés comme champs de bits. Utilisez l' attribut Flags (et assurez-vous que les membres de l'énumération ont des valeurs numériques appropriées).

La constante AC # est similaire à une variable en ce qu'elle donne un nom défini à une valeur. Cependant, une constante diffère d'une variable standard car une fois définie, la valeur affectée à la constante ne peut jamais être modifiée. Le principal avantage des constantes est leur aide à la création de code auto-documenté et permet la déclaration des valeurs clés en un seul endroit, ce qui permet une maintenance facile si la valeur doit être mise à jour et le logiciel recompilé.

Alors que les listes d'énumérateurs sont utiles pour définir des séquences et des états, en particulier lorsqu'il y a une progression naturelle à travers ces états. En effet, chaque constante de la liste peut être formatée et comparée en utilisant son nom ou sa valeur. Une énumération peut également être utilisée pour définir un ensemble limité de valeurs valides.

Une chose que je trouve pratique lorsque vous utilisez à la enumplace de constest que vous pouvez parcourir les valeurs dans un enum, c'est beaucoup plus difficile de le faire avec des constvaleurs.