Choisir la valeur par défaut d'un type Enum sans avoir à modifier les valeurs

En C #, est-il possible de décorer un type Enum avec un attribut ou de faire autre chose pour spécifier quelle devrait être la valeur par défaut, sans avoir à changer les valeurs? Les nombres requis peuvent être gravés dans la pierre pour une raison quelconque, et il serait pratique d'avoir toujours le contrôle sur la valeur par défaut.

enum Orientation
{
    None = -1,
    North = 0,
    East = 1,
    South = 2,
    West = 3
}

Orientation o; // Is 'North' by default.

La valeur par défaut pour un enum(en fait, n'importe quel type de valeur) est 0 - même si ce n'est pas une valeur valide pour cela enum. Cela ne peut pas être changé.

La valeur par défaut de toute énumération est zéro. Donc, si vous souhaitez définir un énumérateur comme valeur par défaut, définissez-le sur zéro et tous les autres énumérateurs sur non-zéro (le premier énumérateur à avoir la valeur zéro sera la valeur par défaut de cette énumération s'il existe plusieurs énumérateurs). avec la valeur zéro).

enum Orientation
{
    None = 0, //default value since it has the value '0'
    North = 1,
    East = 2,
    South = 3,
    West = 4
}

Orientation o; // initialized to 'None'

Si vos énumérateurs n'ont pas besoin de valeurs explicites, assurez-vous simplement que le premier énumérateur est celui que vous souhaitez être l'énumérateur par défaut, car "Par défaut, le premier énumérateur a la valeur 0 et la valeur de chaque énumérateur successif est augmentée de 1." ( Référence C # )

enum Orientation
{
    None, //default value since it is the first enumerator
    North,
    East,
    South,
    West
}

Orientation o; // initialized to 'None'

Si zéro ne fonctionne pas comme valeur par défaut appropriée, vous pouvez utiliser le modèle de composant pour définir une solution de contournement pour l'énumération:

[DefaultValue(None)]
public enum Orientation
{
     None = -1,
     North = 0,
     East = 1,
     South = 2,
     West = 3
 }

public static class Utilities
{
    public static TEnum GetDefaultValue<TEnum>() where TEnum : struct
    {
        Type t = typeof(TEnum);
        DefaultValueAttribute[] attributes = (DefaultValueAttribute[])t.GetCustomAttributes(typeof(DefaultValueAttribute), false);
        if (attributes != null &&
            attributes.Length > 0)
        {
            return (TEnum)attributes[0].Value;
        }
        else
        {
            return default(TEnum);
        }
    }
}

puis vous pouvez appeler:

Orientation o = Utilities.GetDefaultValue<Orientation>();
System.Diagnostics.Debug.Print(o.ToString());

Remarque: vous devrez inclure la ligne suivante en haut du fichier:

using System.ComponentModel;

Cela ne change pas la valeur par défaut réelle du langage C # de l'énumération, mais donne un moyen d'indiquer (et d'obtenir) la valeur par défaut souhaitée.

La valeur par défaut d'une énumération correspond à l'énumération égale à zéro. Je ne crois pas que cela soit modifiable par attribut ou par d'autres moyens.

(MSDN dit: "La valeur par défaut d'une énumération E est la valeur produite par l'expression (E) 0.")

Vous ne pouvez pas, mais si vous le souhaitez, vous pouvez faire un tour. :)

    public struct Orientation
    {
        ...
        public static Orientation None = -1;
        public static Orientation North = 0;
        public static Orientation East = 1;
        public static Orientation South = 2;
        public static Orientation West = 3;
    }

utilisation de cette structure comme énumération simple.
où vous pouvez créer pa == Orientation.East (ou toute valeur que vous voulez) par défaut
pour utiliser l'astuce elle-même, vous devez convertir int par code.
là l'implémentation:

        #region ConvertingToEnum
        private int val;
        static Dictionary<int, string> dict = null;

        public Orientation(int val)
        {
            this.val = val;
        }

        public static implicit operator Orientation(int value)
        {
            return new Orientation(value - 1);
        }

        public static bool operator ==(Orientation a, Orientation b)
        {
            return a.val == b.val;
        }

        public static bool operator !=(Orientation a, Orientation b)
        {
            return a.val != b.val;
        }

        public override string ToString()
        {
            if (dict == null)
                InitializeDict();
            if (dict.ContainsKey(val))
                return dict[val];
            return val.ToString();
        }

        private void InitializeDict()
        {
            dict = new Dictionary<int, string>();
            foreach (var fields in GetType().GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                dict.Add(((Orientation)fields.GetValue(null)).val, fields.Name);
            }
        } 
        #endregion

Une autre façon qui pourrait être utile - d'utiliser une sorte d'alias. Par exemple:

public enum Status
{
    New = 10,
    Old = 20,
    Actual = 30,

    // Use Status.Default to specify default status in your code. 
    Default = New 
}

En fait, enumla valeur par défaut de an est le premier élément du enumdont la valeur est 0.

Ainsi, par exemple:

public enum Animals
{
    Cat,
    Dog,
    Pony = 0,
}
//its value will actually be Cat not Pony unless you assign a non zero value to Cat.
Animals animal;

The default value of enum is the enummember equal to 0 or the first element(if value is not specified) ... Mais j'ai rencontré des problèmes critiques en utilisant enum dans mes projets et surmonté en faisant quelque chose ci-dessous ... Comment mon besoin était-il lié au niveau de la classe ...

    class CDDtype
    {
        public int Id { get; set; }
        public DDType DDType { get; set; }

        public CDDtype()
        {
            DDType = DDType.None;
        }
    }    


    [DefaultValue(None)]
    public enum DDType
    {       
        None = -1,       
        ON = 0,       
        FC = 1,       
        NC = 2,       
        CC = 3
    }

et obtenir le résultat attendu

    CDDtype d1= new CDDtype();
    CDDtype d2 = new CDDtype { Id = 50 };

    Console.Write(d1.DDType);//None
    Console.Write(d2.DDType);//None

Maintenant, que se passe-t-il si la valeur provient de DB ... Ok dans ce scénario ... passez la valeur dans la fonction ci-dessous et cela convertira la valeur enum ... sous la fonction gérée divers scénarios et c'est générique ... et croyez-moi, c'est très vite ..... :)

    public static T ToEnum<T>(this object value)
    {
        //Checking value is null or DBNull
        if (!value.IsNull())
        {
            return (T)Enum.Parse(typeof(T), value.ToStringX());
        }

        //Returanable object
        object ValueToReturn = null;

        //First checking whether any 'DefaultValueAttribute' is present or not
        var DefaultAtt = (from a in typeof(T).CustomAttributes
                          where a.AttributeType == typeof(DefaultValueAttribute)
                          select a).FirstOrNull();

        //If DefaultAttributeValue is present
        if ((!DefaultAtt.IsNull()) && (DefaultAtt.ConstructorArguments.Count == 1))
        {
            ValueToReturn = DefaultAtt.ConstructorArguments[0].Value;
        }

        //If still no value found
        if (ValueToReturn.IsNull())
        {
            //Trying to get the very first property of that enum
            Array Values = Enum.GetValues(typeof(T));

            //getting very first member of this enum
            if (Values.Length > 0)
            {
                ValueToReturn = Values.GetValue(0);
            }
        }

        //If any result found
        if (!ValueToReturn.IsNull())
        {
            return (T)Enum.Parse(typeof(T), ValueToReturn.ToStringX());
        }

        return default(T);
    }

La valeur par défaut pour un type d'énumération est 0:

• " Par défaut, le premier énumérateur a la valeur 0 et la valeur de chaque énumérateur successif est augmentée de 1. "

• " Le type de valeur enum a la valeur produite par l'expression (E) 0, où E est l'identificateur d'énumération. "

Vous pouvez consulter la documentation de l'énumération C # ici et la documentation de la table des valeurs par défaut C # ici .

Si vous définissez l'énumération par défaut comme l'énumération avec la plus petite valeur, vous pouvez utiliser ceci:

public enum MyEnum { His = -1, Hers = -2, Mine = -4, Theirs = -3 }

var firstEnum = ((MyEnum[])Enum.GetValues(typeof(MyEnum)))[0];

firstEnum == Mine.

Cela ne suppose pas que l'énumération a une valeur nulle.

La valeur par défaut est la première de la définition. Par exemple:

public enum MyEnum{His,Hers,Mine,Theirs}

Enum.GetValues(typeOf(MyEnum)).GetValue(0);

Cela reviendra His

enum Orientations
{
    None, North, East, South, West
}
private Orientations? _orientation { get; set; }

public Orientations? Orientation
{
    get
    {
        return _orientation ?? Orientations.None;
    }
    set
    {
        _orientation = value;
    }
}

Si vous définissez la propriété sur null retournera Orientations.Aucun sur get. La propriété _orientation est nulle par défaut.

[DefaultValue(None)]
public enum Orientation
{
    None = -1,
    North = 0,
    East = 1,
    South = 2,
    West = 3
}

Ensuite, dans le code, vous pouvez utiliser

public Orientation GetDefaultOrientation()
{
   return default(Orientation);
}