Scelta del valore predefinito di un tipo Enum senza dover modificare i valori

In C #, è possibile decorare un tipo Enum con un attributo o fare qualcos'altro per specificare quale dovrebbe essere il valore predefinito, senza cambiare i valori? I numeri richiesti potrebbero essere impostati su pietra per qualsiasi motivo, e sarebbe utile avere ancora il controllo sul valore predefinito.

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

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

Il valore predefinito per un enum(in effetti, qualsiasi tipo di valore) è 0, anche se questo non è un valore valido per quello enum. Non può essere cambiato.

Il valore predefinito di qualsiasi enum è zero. Pertanto, se si desidera impostare un enumeratore come valore predefinito, impostare quello su zero e tutti gli altri enumeratori su zero (il primo enumeratore con valore zero sarà il valore predefinito per quell'enum se sono presenti più enumeratori con il valore zero).

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'

Se i tuoi enumeratori non hanno bisogno di valori espliciti, assicurati solo che il primo enumeratore sia quello che desideri sia l'enumeratore predefinito poiché "Per impostazione predefinita, il primo enumeratore ha il valore 0 e il valore di ciascun enumeratore successivo è aumentato di 1." ( Riferimento C # )

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

Orientation o; // initialized to 'None'

Se zero non funziona come valore predefinito corretto, è possibile utilizzare il modello di componente per definire una soluzione alternativa per l'enum:

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

e quindi puoi chiamare:

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

Nota: sarà necessario includere la seguente riga nella parte superiore del file:

using System.ComponentModel;

Ciò non modifica il valore predefinito predefinito del linguaggio C # dell'enum, ma fornisce un modo per indicare (e ottenere) il valore predefinito desiderato.

Il valore predefinito di un enum è qualunque enumerazione equivalga a zero. Non credo che questo sia modificabile da attributi o altri mezzi.

(MSDN dice: "Il valore predefinito di un enum E è il valore prodotto dall'espressione (E) 0.")

Non puoi, ma se vuoi, puoi fare qualche trucco. :)

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

utilizzo di questa struttura come semplice enum.
dove è possibile creare pa == Orientation.East (o qualsiasi valore desiderato) per impostazione predefinita
per utilizzare il trucco stesso, è necessario convertire da int per codice.
lì l'implementazione:

        #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

Un altro modo che potrebbe essere utile: usare una sorta di "alias". Per esempio:

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

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

In realtà un enumdefault è il primo elemento nel enumcui valore è0 .

Quindi per esempio:

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) ... Ma ho affrontato problemi critici usando enum nei miei progetti e superato facendo qualcosa di seguito ... Quanto mai il mio bisogno era legato al livello di 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
    }

e ottieni il risultato atteso

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

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

Ora cosa succede se il valore viene dal DB .... Ok in questo scenario ... passa il valore nella funzione sottostante e convertirà il valore in enum ... la funzione sottostante ha gestito vari scenari ed è generica ... e credimi è molto veloce ..... :)

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

Il valore predefinito per un tipo di enumerazione è 0:

• " Per impostazione predefinita, il primo enumeratore ha il valore 0 e il valore di ciascun enumeratore successivo viene aumentato di 1 ".

• " Il tipo di valore enum ha il valore prodotto dall'espressione (E) 0, dove E è l'identificatore enum. "

È possibile controllare la documentazione per C # enum qui e la documentazione per la tabella dei valori predefiniti C # qui .

Se si definisce l'enum predefinito come l'enum con il valore più piccolo, è possibile utilizzare questo:

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

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

firstEnum == Mine.

Ciò non presuppone che l'enum abbia un valore zero.

L'impostazione predefinita è la prima nella definizione. Per esempio:

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

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

Questo tornerà His

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

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

Se si imposta la proprietà su null, verrà restituito Orientations.Nessuno su get. La proprietà _orientation è nulla per impostazione predefinita.

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

Quindi nel codice è possibile utilizzare

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