Elegir el valor predeterminado de un tipo Enum sin tener que cambiar los valores

En C #, ¿es posible decorar un tipo Enum con un atributo o hacer otra cosa para especificar cuál debería ser el valor predeterminado, sin tener que cambiar los valores? Los números requeridos pueden establecerse en piedra por cualquier razón, y sería útil tener control sobre el valor predeterminado.

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

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

El valor predeterminado para un enum(de hecho, cualquier tipo de valor) es 0, incluso si ese no es un valor válido para eso enum. No se puede cambiar.

El valor predeterminado de cualquier enumeración es cero. Entonces, si desea establecer un enumerador como valor predeterminado, establezca ese uno en cero y todos los demás enumeradores en no cero (el primer enumerador que tenga el valor cero será el valor predeterminado para esa enumeración si hay varios enumeradores con el valor cero).

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 sus enumeradores no necesitan valores explícitos, simplemente asegúrese de que el primer enumerador sea el que desea que sea el enumerador predeterminado, ya que "Por defecto, el primer enumerador tiene el valor 0, y el valor de cada enumerador sucesivo aumenta en 1. " ( Referencia de C # )

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

Orientation o; // initialized to 'None'

Si cero no funciona como el valor predeterminado adecuado, puede usar el modelo de componente para definir una solución alternativa para la enumeración:

[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);
        }
    }
}

y luego puedes llamar:

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

Nota: deberá incluir la siguiente línea en la parte superior del archivo:

using System.ComponentModel;

Esto no cambia el valor predeterminado real del lenguaje C # de la enumeración, pero proporciona una forma de indicar (y obtener) el valor predeterminado deseado.

El valor predeterminado de una enumeración es cualquier enumeración equivalente a cero. No creo que esto se pueda cambiar por atributo u otros medios.

(MSDN dice: "El valor predeterminado de una enumeración E es el valor producido por la expresión (E) 0").

No puedes, pero si quieres, puedes hacer algún truco. :)

    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;
    }

uso de esta estructura como enumeración simple.
donde puede crear pa == Orientation.East (o cualquier valor que desee) de forma predeterminada
para usar el truco en sí, debe convertir de int por código.
allí la implementación:

        #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

Una forma más que podría ser útil: utilizar algún tipo de "alias". Por ejemplo:

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

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

En realidad enum, el valor predeterminado de an es el primer elemento en enumcuyo valor es 0.

Así por ejemplo:

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) ... Pero me he enfrentado a problemas críticos al usar la enumeración en mis proyectos y los he superado al hacer algo a continuación ... Cómo siempre se relacionó mi necesidad con el nivel de la clase ...

    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
    }

y obtener el resultado esperado

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

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

Ahora, ¿qué pasa si el valor proviene de DB ... Ok, en este escenario ... pase el valor en la función a continuación y convertirá el valor en enum ... la función a continuación manejó varios escenarios y es genérico ... muy rapido ..... :)

    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);
    }

El valor predeterminado para un tipo de enumeración es 0:

• " Por defecto, el primer enumerador tiene el valor 0, y el valor de cada enumerador sucesivo se incrementa en 1. "

• " El tipo de valor enum tiene el valor producido por la expresión (E) 0, donde E es el identificador de enumeración " .

Puede consultar la documentación para la enumeración de C # aquí , y la documentación para la tabla de valores predeterminados de C # aquí .

Si define la enumeración predeterminada como la enumeración con el valor más pequeño, puede usar esto:

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

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

firstEnum == Mine.

Esto no supone que la enumeración tenga un valor cero.

El valor predeterminado es el primero en la definición. Por ejemplo:

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

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

Esto volverá 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 establece la propiedad en nulo, devolverá Orientaciones. Ninguna en get. La propiedad _orientation es nula por defecto.

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

Luego en el código puedes usar

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