Valeur initiale d'un Enum

Question

J'ai une classe avec une propriété qui est un ENUM

ENUM est

/// <summary> 
/// All available delivery actions 
/// </summary> 
public enum EnumDeliveryAction 
    { 
    /// <summary> 
    /// Tasks with email delivery action will be emailed 
    /// </summary> 
    Email, 

    /// <summary> 
    /// Tasks with SharePoint delivery action 
    /// </summary> 
    SharePoint 
    } 

Lorsque je crée une instance de cette classe, NOWHERE dans le code, dois-je spécifier la valeur du champ enum, mais il semble que par défaut le premier élément de la liste enumlist, et non une valeur nulle, est-ce comment cela fonctionne enums? Comment est-il possible de s'assurer que l'enum obtient une sorte de valeur nulle si elle n'est pas définie, je ne veux pas qu'elle soit par défaut à la première valeur de l'énumération.

Answer 1

La valeur par défaut pour les types enum est 0 (qui est par défaut le premier élément de l'énumération). Les champs d'une classe seront initialisés à la valeur par défaut.

Si vous avez besoin de représenter une valeur inconnue dans le ENUM, vous pouvez ajouter un élément Unknown avec la valeur 0. Sinon, vous pouvez déclarer le terrain Nullable<MyEnum> (MyEnum?).

Answer 2

Les énumérations sont un type de valeur, comme les entiers. Vous devez le rendre nullable afin de ne pas utiliser par défaut le premier membre (ou 0-défini) enum.

public class MyClass 
{ 
    public EnumDeliveryAction? DeliveryAction { get; set;} 
} 

Answer 3

Les champs enum sont initialisés comme zéro; Si vous ne spécifiez pas de valeurs dans une énumération, elles commencent à zéro (Email = 0, SharePoint=1, etc.). Par conséquent, par défaut, tout champ initialisé sera Email. Il est relativement commun d'ajouter None=0 pour de tels cas, ou bien d'utiliser Nullable<T>; à savoir

/// <summary> 
/// All available delivery actions 
/// </summary> 
public enum EnumDeliveryAction 
{ 
    /// <summary> 
    /// Not specified 
    /// </summary> 
    None, 

    /// <summary> 
    /// Tasks with email delivery action will be emailed 
    /// </summary> 
    Email, 

    /// <summary> 
    /// Tasks with SharePoint delivery action 
    /// </summary> 
    SharePoint 
} 

Vous devez également être sûr de traiter jamais votre dernière valeur attendue par défaut; à savoir

switch(action) { 
    case EnumDeliveryAction.Email; RunEmail(); break; 
    default: RunSharePoint(); break; 
} 

cela devrait être:

switch(action) { 
    case EnumDeliveryAction.Email; RunEmail(); break; 
    case EnumDeliveryAction.SharePoint; RunSharePoint(); break; 
    default: throw new InvalidOperationException(
      "Unexpected action: " + action); 
} 

Answer 4

Le aproche traditionnel d'ajouter une valeur nulle aux valeurs qui ne sont généralement pas un est de déclarer votre variable comme un type nullable, à savoir:

EnumDeliveryAction? action=null; 

Answer 5

Je suggérerais d'avoir une valeur de None = 0 comme première valeur enum. Rendez-le explicite, alors vous savez avec certitude quelle est sa valeur.

Answer 6

Vous pouvez démarrer vos énumérations à n'importe quelle valeur (telle que 1), mais lorsqu'elles représentent une valeur de recherche dans une base de données, vous souhaitez généralement qu'elles correspondent.

Je déclare généralement le premier Enum comme Aucun (= 0) lorsque cela est logique, conformément aux directives du .Net Framework Design.

Answer 7

La meilleure pratique (comme conseillé par l'analyse de code) est de toujours avoir une valeur par défaut dans vos énumérations, qui représentent une valeur non définie.

Donc, dans votre cas, vous pourriez avoir:

public enum EnumDeliveryAction 
    { 

    /// <summary> 
    /// Default value 
    /// </summary> 
    NotSet, 

    /// <summary> 
    /// Tasks with email delivery action will be emailed 
    /// </summary> 
    Email, 

    /// <summary> 
    /// Tasks with SharePoint delivery action 
    /// </summary> 
    SharePoint 
    } 

En aparté, vous ne devriez pas préfixer le nom du ENUM avec Enum. Vous pouvez envisager de changer pour:

public enum DeliveryAction; 

Answer 8

Par défaut, seuls les types de référence sont des types NULLable. Si vous voulez qu'une variable autorise les valeurs nulles, vous devez la définir comme nulle en utilisant le "?" caractère (pour cela, vous avez besoin de C# 2.0 ou plus).

enum MyEnum 
{ 
    ValueOne, 
    ValueTwo 
} 

et dans votre classe

MyEnum? myvariable = null; 

Answer 9

énumérations sont des types de valeur. Les types de valeurs ne peuvent pas être nuls et sont initialisés à 0.

Même si votre ENUM ne possède pas de 0, les variables ENUM seront initialisées à 0.

public enum SomeEnum 
{ 
    A = 1, 
    B = 2 
} 

(plus tard)

SomeEnum x = default(SomeEnum); 
Console.WriteLine(x); 

sorties - 0

---

Certains answerers préconisent l'utilisation Nullable<T> pour correspondre à votre i attentes de nitialisation. Attention à ce conseil puisque Nullable<T> est toujours un type de valeur et a une sémantique différente de celle des types de référence. Par exemple, il ne générera jamais une exception de référence nulle (ce n'est pas une référence).

SomeEnum? x = default(SomeEnum?); 

if (x == null) 
{ 
    Console.WriteLine("It's null!"); 
} 
if (x > SomeEnum.B) 
{ 
} 
else 
{ 
    Console.WriteLine("This runs even though you don't expect it to"); 
} 

Answer 10

Mon C++ professeur (il y a 11 ans) au collège m'a dit que l'éditeur de liens remplace ENUM avec leur type réel:

typedef static const int enum;

Ainsi, chaque fois que vous écrivez quelque chose comme enum MY_VAL = 5;, vous pourriez remplacer facilement par static const int MY_VAL = 5; (mais cela rend votre code plus long ...).

Quoi qu'il en soit, la valeur par défaut de tout int est 0.

Enum