Holen Sie sich den int-Wert von enum in C #

Ich habe eine Klasse namens Questions(Plural). In dieser Klasse gibt es eine Aufzählung namens Question(Singular), die so aussieht.

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

In der QuestionsKlasse habe ich eine get(int foo)Funktion, die ein QuestionsObjekt dafür zurückgibt foo. Gibt es eine einfache Möglichkeit, den ganzzahligen Wert aus der Aufzählung zu entfernen, damit ich so etwas tun kann Questions.Get(Question.Role)?

Wirf einfach die Aufzählung, z

int something = (int) Question.Role;

Das Obige funktioniert für die überwiegende Mehrheit der Aufzählungen, die Sie in freier Wildbahn sehen, da der zugrunde liegende Standardtyp für eine Aufzählung lautet int.

Wie Cecilphillip jedoch betont, können Aufzählungen unterschiedliche zugrunde liegende Typen haben. Wenn eine Aufzählung als , oder deklariert uintist long, ulongsollte sie in den Typ der Aufzählung umgewandelt werden. zB für

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

du solltest benutzen

long something = (long)StarsInMilkyWay.Wolf424B;

Da Aufzählungen jeder integraler Typ sein können ( byte, int, short, usw.), eine robustere Art und Weise den zugrunde liegenden Integralwert des Enum zu bekommen wäre die Verwendung der machen GetTypeCodeMethode in Verbindung mit der ConvertKlasse:

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

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

Dies sollte unabhängig vom zugrunde liegenden Integraltyp funktionieren.

Deklarieren Sie es als statische Klasse mit öffentlichen Konstanten:

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

Und dann können Sie darauf verweisen Question.Role, und es wird immer zu einem intoder was auch immer Sie es definieren ausgewertet .

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

Wird dazu führen value == 2.

In einem verwandten Hinweis, wenn Sie den intWert von erhalten möchten System.Enum, dann ehier angegeben:

Enum e = Question.Role;

Sie können verwenden:

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

Die letzten beiden sind einfach hässlich. Ich bevorzuge den ersten.

Es ist einfacher als Sie denken - eine Aufzählung ist bereits eine int. Es muss nur daran erinnert werden:

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

Beispiel:

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

Und im Code dahinter, um den Aufzählungswert zu erhalten:

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

oder

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

Aufzählungen werden um 1 erhöht, und Sie können den Startwert festlegen. Wenn Sie den Startwert nicht einstellen, wird er zunächst als 0 zugewiesen.

Ich habe kürzlich von der Verwendung von Aufzählungen in meinem Code auf die Verwendung von Klassen mit geschützten Konstruktoren und vordefinierten statischen Instanzen umgestellt (dank Roelof - C # Sicherstellen gültiger Aufzählungswerte - Zukunftssichere Methode ).

In Anbetracht dessen würde ich im Folgenden näher auf dieses Problem eingehen (einschließlich der impliziten Konvertierung nach / von 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)
}

Der Vorteil dieses Ansatzes besteht darin, dass Sie alles, was Sie hätten, aus der Aufzählung erhalten, aber Ihr Code ist jetzt viel flexibler. Sollten Sie also verschiedene Aktionen basierend auf dem Wert von ausführen müssen Question, können Sie Logik in sich Questionselbst einfügen (dh in der bevorzugten OO) Mode) im Gegensatz zu vielen case-Anweisungen in Ihrem Code, um jedes Szenario anzugehen.

NB: Antwort aktualisiert am 27.04.2018, um die C # 6-Funktionen zu nutzen. dh Deklarationsausdrücke und Lambda-Ausdruckskörperdefinitionen. Siehe Revisionsverlauf für Original - Code. Dies hat den Vorteil, dass die Definition etwas weniger ausführlich ist. Dies war eine der Hauptbeschwerden über den Ansatz dieser Antwort.

Wenn Sie eine Ganzzahl für den Enum-Wert erhalten möchten, der in einer Variablen gespeichert ist, für die der Typ wäre Question, um ihn beispielsweise in einer Methode zu verwenden, können Sie dies einfach tun, den ich in diesem Beispiel geschrieben habe:

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

Dadurch wird der Fenstertitel in 4 geändert, da die Variable Geselecteerdlautet Talen.Nederlands. Wenn ich es in ändere Talen.Portugeesund die Methode erneut aufrufe, ändert sich der Text in 3.

Um sicherzustellen, dass ein Aufzählungswert vorhanden ist, und ihn dann zu analysieren, können Sie auch Folgendes tun.

// 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() + ".");

Vielleicht habe ich es verpasst, aber hat jemand eine einfache generische Erweiterungsmethode ausprobiert?

Das funktioniert gut für mich. Sie können die Typumwandlung in Ihrer API auf diese Weise vermeiden, aber letztendlich führt dies zu einer Änderungstypoperation. Dies ist ein guter Fall für die Programmierung von Roslyn , damit der Compiler eine GetValue <T> -Methode für Sie erstellt.

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

Noch eine Möglichkeit:

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

Es wird ergeben:

Name: Role, Value: 2

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

... ist eine schöne Erklärung.

Sie müssen das Ergebnis wie folgt in int umwandeln:

int Question = (int)QuestionType.Role

Ansonsten ist der Typ noch QuestionType .

Diese Strenge ist der C # -Weg.

Eine Alternative besteht darin, stattdessen eine Klassendeklaration zu verwenden:

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
}

Es ist weniger elegant zu deklarieren, aber Sie müssen es nicht in Code umwandeln:

int Question = QuestionType.Role

Alternativ können Sie sich mit Visual Basic wohler fühlen, das diese Art von Erwartung in vielen Bereichen erfüllt.

int number = Question.Role.GetHashCode();

numbersollte den Wert haben 2.

Sie können dies tun, indem Sie eine Erweiterungsmethode für Ihren definierten Aufzählungstyp implementieren :

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

Dies vereinfacht das Abrufen des int-Werts des aktuellen Aufzählungswerts:

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

oder

int value = Question.Role.getNumberValue();

Verwenden Sie stattdessen eine Erweiterungsmethode:

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

Und die Verwendung ist etwas hübscher:

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

Verwenden:

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

Es wird dazu führen value == 2 .

Dies gilt nur, wenn die Aufzählung in eine passt int.

Da Aufzählungen mit mehreren primitiven Typen deklariert werden können, kann eine generische Erweiterungsmethode zum Umwandeln eines beliebigen Aufzählungstyps hilfreich sein.

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;

Es folgt die Erweiterungsmethode

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

Mein Lieblingshack mit int oder kleineren Aufzählungen:

GetHashCode();

Für eine Aufzählung

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

Diese,

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

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

Ausgänge

one
1
1
max
2147483647
2147483647
min
-2147483648
-2147483648

Haftungsausschluss:

Es funktioniert nicht für lange Aufzählungen.

Die einfachste Lösung, die ich mir vorstellen kann, ist das Überladen der Get(int)Methode wie folgt :

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

wo [modifiers]kann im Allgemeinen das gleiche sein wie für die Get(int)Methode. Wenn Sie die QuestionsKlasse nicht bearbeiten können oder aus irgendeinem Grund nicht möchten, können Sie die Methode überladen, indem Sie eine Erweiterung schreiben:

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

Das Beispiel, das ich vorschlagen möchte, "um einen 'int'-Wert aus einer Aufzählung zu erhalten", ist

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

int answer = (int)Sample.Book;

Jetzt lautet die Antwort 1.

Verwenden:

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

Versuchen Sie dies, anstatt enum in int umzuwandeln:

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

In Visual Basic sollte es sein:

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

Private value As Integer = CInt(Question.Role)

Ich habe mir diese Erweiterungsmethode ausgedacht, die aktuelle Sprachfunktionen enthält. Durch die Verwendung von dynamic muss ich dies nicht zu einer generischen Methode machen und den Typ angeben, der den Aufruf einfacher und konsistenter hält:

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