Uzyskaj wartość int z enum w C #

Mam klasę o nazwie Questions(liczba mnoga). W tej klasie jest wyliczenie zwane Question(liczba pojedyncza), które wygląda tak.

public enum Question
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

W Questionsklasie mam get(int foo)funkcję, która zwraca do tego Questionsobiekt foo. Czy istnieje prosty sposób na usunięcie wartości całkowitej z wyliczenia, aby móc zrobić coś takiego Questions.Get(Question.Role)?

Wystarczy rzucić wyliczenie, np

int something = (int) Question.Role;

Powyższe będzie działać dla ogromnej większości wyliczeń, które widzisz na wolności, ponieważ domyślnym rodzajem wyliczenia jest int.

Jednak, jak wskazuje Cecilphillip , wyliczenia mogą mieć różne podstawowe typy. Jeśli enum jest zadeklarowana jako uint, longlub ulong, powinno być oddane do typu wyliczenia; np. dla

enum StarsInMilkyWay:long {Sun = 1, V645Centauri = 2 .. Wolf424B = 2147483649};

powinieneś użyć

long something = (long)StarsInMilkyWay.Wolf424B;

Ponieważ wyliczenia może być dowolny integralną typu ( byte, int, short, itd.), Bardziej wydajny sposób, aby uzyskać wartości bazowej całka wyliczenia byłoby skorzystać z GetTypeCodemetody w połączeniu z Convertklasą:

enum Sides {
    Left, Right, Top, Bottom
}
Sides side = Sides.Bottom;

object val = Convert.ChangeType(side, side.GetTypeCode());
Console.WriteLine(val);

Powinno to działać niezależnie od podstawowego typu całki.

Zadeklaruj jako klasę statyczną o stałych publicznych:

public static class Question
{
    public const int Role = 2;
    public const int ProjectFunding = 3;
    public const int TotalEmployee = 4;
    public const int NumberOfServers = 5;
    public const int TopBusinessConcern = 6;
}

A potem możesz odwołać się do niego jako Question.Rolei zawsze będzie to ewaluacja do intczegoś, co zdefiniujesz jako.

Question question = Question.Role;
int value = (int) question;

Spowoduje w value == 2.

W powiązanej notatce, jeśli chcesz uzyskać intwartość System.Enum, podaj etutaj:

Enum e = Question.Role;

Możesz użyć:

int i = Convert.ToInt32(e);
int i = (int)(object)e;
int i = (int)Enum.Parse(e.GetType(), e.ToString());
int i = (int)Enum.ToObject(e.GetType(), e);

Dwa ostatnie są po prostu brzydkie. Wolę pierwszy.

To łatwiejsze niż myślisz - wyliczenie to już int. Trzeba tylko przypomnieć:

int y = (int)Question.Role;
Console.WriteLine(y); // Prints 2

Przykład:

public Enum EmpNo
{
    Raj = 1,
    Rahul,
    Priyanka
}

A w kodzie z tyłu, aby uzyskać wartość wyliczenia:

int setempNo = (int)EmpNo.Raj; // This will give setempNo = 1

lub

int setempNo = (int)EmpNo.Rahul; // This will give setempNo = 2

Wyliczenia będą zwiększane o 1 i możesz ustawić wartość początkową. Jeśli nie ustawisz wartości początkowej, początkowo zostanie przypisana jako 0.

Niedawno zrezygnowałem z używania wyliczeń w moim kodzie na rzecz zamiast używania klas z chronionymi konstruktorami i predefiniowanymi instancjami statycznymi (dzięki Roelof - C # Upewnij się, że Valum Enum Values ​​- Futureproof Method ).

W związku z tym poniżej przedstawiam teraz ten problem (w tym niejawną konwersję do / z int).

public class Question
{
    // Attributes
    protected int index;
    protected string name;
    // Go with a dictionary to enforce unique index
    //protected static readonly ICollection<Question> values = new Collection<Question>();
    protected static readonly IDictionary<int,Question> values = new Dictionary<int,Question>();

    // Define the "enum" values
    public static readonly Question Role = new Question(2,"Role");
    public static readonly Question ProjectFunding = new Question(3, "Project Funding");
    public static readonly Question TotalEmployee = new Question(4, "Total Employee");
    public static readonly Question NumberOfServers = new Question(5, "Number of Servers");
    public static readonly Question TopBusinessConcern = new Question(6, "Top Business Concern");

    // Constructors
    protected Question(int index, string name)
    {
        this.index = index;
        this.name = name;
        values.Add(index, this);
    }

    // Easy int conversion
    public static implicit operator int(Question question) =>
        question.index; //nb: if question is null this will return a null pointer exception

    public static implicit operator Question(int index) =>        
        values.TryGetValue(index, out var question) ? question : null;

    // Easy string conversion (also update ToString for the same effect)
    public override string ToString() =>
        this.name;

    public static implicit operator string(Question question) =>
        question?.ToString();

    public static implicit operator Question(string name) =>
        name == null ? null : values.Values.FirstOrDefault(item => name.Equals(item.name, StringComparison.CurrentCultureIgnoreCase));


    // If you specifically want a Get(int x) function (though not required given the implicit converstion)
    public Question Get(int foo) =>
        foo; //(implicit conversion will take care of the conversion for you)
}

Zaletą tego podejścia jest to, że otrzymujesz wszystko, co miałbyś z wyliczenia, ale twój kod jest teraz znacznie bardziej elastyczny, więc jeśli musisz wykonywać różne działania w oparciu o wartość Question, możesz umieścić logikę w Questionsobie (tj. W preferowanym OO moda), w przeciwieństwie do umieszczania wielu instrukcji w całym kodzie w celu rozwiązania każdego scenariusza.

NB: Odpowiedź zaktualizowana 27.04.2018, aby skorzystać z funkcji C # 6; tzn. wyrażenia deklaracyjne i definicje treści wyrażeń lambda. Zobacz historię zmian dla oryginalnego kodu. Ma to tę zaletę, że definicja jest nieco mniej szczegółowa; która była jedną z głównych skarg na podejście tej odpowiedzi.

Jeśli chcesz uzyskać liczbę całkowitą dla wartości wyliczonej, która jest przechowywana w zmiennej, dla której typ byłby Question, na przykład w metodzie, możesz po prostu zrobić to, co napisałem w tym przykładzie:

enum Talen
{
    Engels = 1, Italiaans = 2, Portugees = 3, Nederlands = 4, Duits = 5, Dens = 6
}

Talen Geselecteerd;    

public void Form1()
{
    InitializeComponent()
    Geselecteerd = Talen.Nederlands;
}

// You can use the Enum type as a parameter, so any enumeration from any enumerator can be used as parameter
void VeranderenTitel(Enum e)
{
    this.Text = Convert.ToInt32(e).ToString();
}

Spowoduje to zmianę tytułu okna na 4, ponieważ zmienną Geselecteerdjest Talen.Nederlands. Jeśli zmienię to na Talen.Portugeesi wywołam ponownie metodę, tekst zmieni się na 3.

Aby upewnić się, że istnieje wartość wyliczenia, a następnie ją przeanalizować, możesz również wykonać następujące czynności.

// Fake Day of Week
string strDOWFake = "SuperDay";

// Real Day of Week
string strDOWReal = "Friday";

// Will hold which ever is the real DOW.
DayOfWeek enmDOW;

// See if fake DOW is defined in the DayOfWeek enumeration.
if (Enum.IsDefined(typeof(DayOfWeek), strDOWFake))
{
    // This will never be reached since "SuperDay"
    // doesn't exist in the DayOfWeek enumeration.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWFake);
}
// See if real DOW is defined in the DayOfWeek enumeration.
else if (Enum.IsDefined(typeof(DayOfWeek), strDOWReal))
{
    // This will parse the string into it's corresponding DOW enum object.
    enmDOW = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), strDOWReal);
}

// Can now use the DOW enum object.
Console.Write("Today is " + enmDOW.ToString() + ".");

Może mi tego brakowało, ale czy ktoś próbował prostej ogólnej metody rozszerzenia?

To działa świetnie dla mnie. W ten sposób można uniknąć rzutowania typu w interfejsie API, ale ostatecznie powoduje to operację zmiany typu. Jest to dobry przypadek do zaprogramowania Roslyn, aby kompilator stworzył dla ciebie metodę GetValue <T>.

    public static void Main()
    {
        int test = MyCSharpWrapperMethod(TestEnum.Test1);

        Debug.Assert(test == 1);
    }

    public static int MyCSharpWrapperMethod(TestEnum customFlag)
    {
        return MyCPlusPlusMethod(customFlag.GetValue<int>());
    }

    public static int MyCPlusPlusMethod(int customFlag)
    {
        // Pretend you made a PInvoke or COM+ call to C++ method that require an integer
        return customFlag;
    }

    public enum TestEnum
    {
        Test1 = 1,
        Test2 = 2,
        Test3 = 3
    }
}

public static class EnumExtensions
{
    public static T GetValue<T>(this Enum enumeration)
    {
        T result = default(T);

        try
        {
            result = (T)Convert.ChangeType(enumeration, typeof(T));
        }
        catch (Exception ex)
        {
            Debug.Assert(false);
            Debug.WriteLine(ex);
        }

        return result;
    }
}

Jeszcze jeden sposób, aby to zrobić:

Console.WriteLine("Name: {0}, Value: {0:D}", Question.Role);

Spowoduje to:

Name: Role, Value: 2

public enum QuestionType
{
    Role = 2,
    ProjectFunding = 3,
    TotalEmployee = 4,
    NumberOfServers = 5,
    TopBusinessConcern = 6
}

... to dobra deklaracja.

Musisz rzucić wynik na int tak:

int Question = (int)QuestionType.Role

W przeciwnym razie typ jest nadal QuestionType .

Ten poziom ścisłości jest sposobem C #.

Jedną z możliwości jest użycie deklaracji klasy zamiast:

public class QuestionType
{
    public static int Role = 2,
    public static int ProjectFunding = 3,
    public static int TotalEmployee = 4,
    public static int NumberOfServers = 5,
    public static int TopBusinessConcern = 6
}

Deklarowanie jest mniej eleganckie, ale nie trzeba go umieszczać w kodzie:

int Question = QuestionType.Role

Alternatywnie możesz czuć się bardziej komfortowo z Visual Basic, który zaspokaja tego rodzaju oczekiwania w wielu obszarach.

int number = Question.Role.GetHashCode();

numberpowinien mieć wartość 2.

Możesz to zrobić, implementując metodę rozszerzenia do zdefiniowanego typu wyliczenia:

public static class MyExtensions
{
    public static int getNumberValue(this Question questionThis)
    {
        return (int)questionThis;
    }
}

Upraszcza to uzyskanie wartości int bieżącej wartości wyliczenia:

Question question = Question.Role;
int value = question.getNumberValue();

lub

int value = Question.Role.getNumberValue();

Zamiast tego użyj metody rozszerzenia:

public static class ExtensionMethods
{
    public static int IntValue(this Enum argEnum)
    {
        return Convert.ToInt32(argEnum);
    }
}

A użycie jest nieco ładniejsze:

var intValue = Question.Role.IntValue();

public enum Suit : int
{
    Spades = 0,
    Hearts = 1,
    Clubs = 2,
    Diamonds = 3
}

Console.WriteLine((int)(Suit)Enum.Parse(typeof(Suit), "Clubs"));

// From int
Console.WriteLine((Suit)1);

// From a number you can also
Console.WriteLine((Suit)Enum.ToObject(typeof(Suit), 1));

if (typeof(Suit).IsEnumDefined("Spades"))
{
    var res = (int)(Suit)Enum.Parse(typeof(Suit), "Spades");
    Console.Out.WriteLine("{0}", res);
}

Posługiwać się:

Question question = Question.Role;
int value = question.GetHashCode();

Spowoduje to value == 2.

Jest to prawdą tylko wtedy, gdy wyliczenie mieści się w int.

Ponieważ wyliczenia można zadeklarować za pomocą wielu typów pierwotnych, użyteczna może być ogólna metoda rozszerzenia do rzutowania dowolnego typu wyliczenia.

enum Box
{
    HEIGHT,
    WIDTH,
    DEPTH
}

public static void UseEnum()
{
    int height = Box.HEIGHT.GetEnumValue<int>();
    int width = Box.WIDTH.GetEnumValue<int>();
    int depth = Box.DEPTH.GetEnumValue<int>();
}

public static T GetEnumValue<T>(this object e) => (T)e;

Poniżej przedstawiono metodę rozszerzenia

public static string ToEnumString<TEnum>(this int enumValue)
{
    var enumString = enumValue.ToString();
    if (Enum.IsDefined(typeof(TEnum), enumValue))
    {
        enumString = ((TEnum) Enum.ToObject(typeof (TEnum), enumValue)).ToString();
    }
    return enumString;
}

Mój ulubiony hack z int lub mniejszymi wyliczeniami:

GetHashCode();

Dla wyliczenia

public enum Test
{
    Min = Int32.MinValue,
    One = 1,
    Max = Int32.MaxValue,
}

To,

var values = Enum.GetValues(typeof(Test));

foreach (var val in values)
{
    Console.WriteLine(val.GetHashCode());
    Console.WriteLine(((int)val));
    Console.WriteLine(val);
}

wyjścia

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Zrzeczenie się:

Nie działa na wyliczenia oparte na długim.

Najłatwiejszym rozwiązaniem jest przeciążenie Get(int)metody w ten sposób:

[modifiers] Questions Get(Question q)
{
    return Get((int)q);
}

gdzie [modifiers]ogólnie może być taki sam jak dla Get(int)metody. Jeśli nie możesz edytować Questionsklasy lub z jakiegoś powodu nie chcesz, możesz przeładować metodę, pisząc rozszerzenie:

public static class Extensions
{
    public static Questions Get(this Questions qs, Question q)
    {
        return qs.Get((int)q);
    }
}

Przykład, który chciałbym zasugerować „aby uzyskać wartość„ int ”z wyliczenia”, to

public enum Sample
{
    Book = 1, 
    Pen = 2, 
    Pencil = 3
}

int answer = (int)Sample.Book;

Teraz odpowiedź będzie wynosić 1.

Posługiwać się:

Question question = Question.Role;
int value = Convert.ToInt32(question);

Wypróbuj ten zamiast konwersji enum na int:

public static class ReturnType
{
    public static readonly int Success = 1;
    public static readonly int Duplicate = 2;
    public static readonly int Error = -1;        
}

W języku Visual Basic powinno to być:

Public Enum Question
    Role = 2
    ProjectFunding = 3
    TotalEmployee = 4
    NumberOfServers = 5
    TopBusinessConcern = 6
End Enum

Private value As Integer = CInt(Question.Role)

Wymyśliłem tę metodę rozszerzenia, która obejmuje bieżące funkcje językowe. Korzystając z dynamiki, nie muszę robić z tego ogólnej metody i określać typ, który sprawia, że ​​wywołanie jest prostsze i spójne:

public static class EnumEx
{
    public static dynamic Value(this Enum e)
    {
        switch (e.GetTypeCode())
        {
            case TypeCode.Byte:
            {
                return (byte) (IConvertible) e;
            }

            case TypeCode.Int16:
            {
                return (short) (IConvertible) e;
            }

            case TypeCode.Int32:
            {
                return (int) (IConvertible) e;
            }

            case TypeCode.Int64:
            {
                return (long) (IConvertible) e;
            }

            case TypeCode.UInt16:
            {
                return (ushort) (IConvertible) e;
            }

            case TypeCode.UInt32:
            {
                return (uint) (IConvertible) e;
            }

            case TypeCode.UInt64:
            {
                return (ulong) (IConvertible) e;
            }

            case TypeCode.SByte:
            {
                return (sbyte) (IConvertible) e;
            }
        }

        return 0;
    }