Wybieranie domyślnej wartości typu Enum bez konieczności zmiany wartości

Czy w języku C # można ozdobić typ Enum atrybutem lub zrobić coś innego, aby określić, jaka powinna być wartość domyślna, bez zmiany wartości? Wymagane liczby mogą być ustawione w kamieniu z jakiegokolwiek powodu, i przydałoby się mieć kontrolę nad ustawieniami domyślnymi.

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

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

Domyślną wartością enum(w rzeczywistości dowolnego typu wartości) jest 0 - nawet jeśli nie jest to poprawna wartość enum. Nie można tego zmienić.

Domyślna wartość dowolnego wyliczenia wynosi zero. Jeśli więc chcesz ustawić jeden moduł wyliczający na wartość domyślną, ustaw ten jeden na zero, a wszystkie inne elementy wyliczające na niezerowe (pierwszy moduł wyliczający, który ma wartość zero, będzie wartością domyślną dla tego wyliczenia, jeśli istnieje kilka modułów wyliczających o wartości 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'

Jeśli twoje moduły wyliczające nie potrzebują jawnych wartości, upewnij się, że pierwszy moduł wyliczający jest tym, który ma być domyślnym urządzeniem wyliczającym, ponieważ „Domyślnie pierwszy moduł wyliczający ma wartość 0, a wartość każdego kolejnego modułu wyliczającego jest zwiększana o 1. ” ( Odniesienie C # )

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

Orientation o; // initialized to 'None'

Jeśli zero nie działa jako poprawna wartość domyślna, możesz użyć modelu komponentu do zdefiniowania obejścia dla wyliczenia:

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

a następnie możesz zadzwonić:

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

Uwaga: w górnej części pliku należy umieścić następujący wiersz:

using System.ComponentModel;

Nie zmienia to faktycznej wartości domyślnej wyliczenia w języku C #, ale umożliwia wskazanie (i uzyskanie) żądanej wartości domyślnej.

Domyślną wartością wyliczenia jest dowolne wyliczenie równe zero. Nie sądzę, że można to zmienić atrybutem lub w inny sposób.

(MSDN mówi: „Domyślną wartością wyliczenia E jest wartość wytworzona przez wyrażenie (E) 0”.)

Nie możesz, ale jeśli chcesz, możesz zrobić jakąś sztuczkę. :)

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

użycie tej struktury jako prostego wyliczenia.
gdzie możesz domyślnie utworzyć pa == Orientation.East (lub dowolną inną wartość),
aby użyć samej lewy, musisz przekonwertować z int przez kod.
tam wdrożenie:

        #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

Jeszcze jeden sposób, który może być pomocny - użycie pewnego rodzaju „aliasu”. Na przykład:

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

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

W rzeczywistości wartością enumdomyślną jest pierwszy element, enumktórego wartością jest 0.

Na przykład:

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) ... Ale napotkałem krytyczne problemy z wykorzystaniem enum w moich projektach i przezwyciężyłem, robiąc coś poniżej ... Jakkolwiek moja potrzeba była związana z poziomem klasy ...

    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
    }

i uzyskaj oczekiwany wynik

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

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

Co jeśli wartość pochodzi z DB ... Ok w tym scenariuszu ... przekaż wartość w poniższej funkcji i przekonwertuje wartość na wyliczoną ... poniżej funkcja obsłużyła różne scenariusze i jest ogólna ... i wierz mi, że to jest bardzo szybki ..... :)

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

Wartość domyślna dla typu wyliczenia wynosi 0:

• „ Domyślnie pierwszy moduł wyliczający ma wartość 0, a wartość każdego kolejnego modułu wyliczającego jest zwiększana o 1. ”

• „ Wyliczenie typu wartości ma wartość wytworzoną przez wyrażenie (E) 0, gdzie E jest identyfikatorem wyliczenia. ”

Możesz sprawdzić dokumentację dla enum C # tutaj , a dokumentację dla wartości domyślnych C # tutaj .

Jeśli zdefiniujesz domyślny wyliczenie jako wyliczenie o najmniejszej wartości, możesz użyć tego:

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

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

firstEnum == Mine.

Nie zakłada to, że wyliczenie ma wartość zerową.

Domyślnie jest to pierwszy w definicji. Na przykład:

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

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

To wróci His

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

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

Jeśli ustawisz właściwość na null, zwróci Orientations.None on get. Właściwość _orientation ma domyślnie wartość NULL.

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

Następnie w kodzie możesz użyć

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