Holen int Wert von Enum in C #

StackOverflow https://stackoverflow.com/questions/943398

  •  09-09-2019
  •  | 
  •  

Frage

Ich habe eine Klasse namens Questions (Plural). In dieser Klasse gibt es eine Enum genannt Question (Singular), die wie folgt aussieht. 

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

In der Questions Klasse habe ich eine get(int foo) Funktion, die ein Questions Objekt für diese foo zurückgibt. Gibt es eine einfache Möglichkeit, den ganzzahligen Wert vom Enum zu bekommen, damit ich so etwas wie Questions.Get(Question.Role) tun?

War es hilfreich?

Lösung

werfen Sie einfach die Enum, z. 

int something = (int) Question.Role;

Das oben wird für die überwiegende Mehrheit der Aufzählungen arbeiten Sie in der freien Natur zu sehen, wie der Standard zugrunde liegende Typ für eine Enum int ist.

Wie jedoch cecilphillip weist darauf hin, können Aufzählungen haben unterschiedliche zugrunde liegenden Typen. Wenn eine Enumeration als uint deklariert wird, long oder ulong, sollte es auf die Art der Enumeration gegossen werden; z.B. für 

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

Sie verwenden sollten, 

long something = (long)StarsInMilkyWay.Wolf424B;

Andere Tipps

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

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

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

Das sollte funktionieren, unabhängig von dem zugrunde liegenden integrierten Typ.

deklariert es als eine 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 kann man es als Question.Role verweisen, und es ergibt immer eine int oder was auch immer Sie definieren es als. 

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

Wird in value == 2 zur Folge haben.

über einen entsprechenden Hinweis, wenn Sie den int Wert von System.Enum zu bekommen, dann gegeben e hier: 

Enum e = Question.Role;

Sie können mit: 

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 nur hässlich. Ich ziehe die erste.

Es ist einfacher als Sie denken - eine Enumeration ist bereits ein 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 hinter dem Code Enum-Wert 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 wird um 1 erhöht, und Sie können den Startwert gesetzt. Wenn Sie nicht setzen den Startwert als 0 anfänglich zugewiesen wird.

Ich habe vor kurzem haben umgewandelt weg Aufzählungen in meinem Code für stattdessen mithilfe von Klassen mit geschützten Konstrukteuren und vordefinierte statische Instanzen verwenden (dank Roelof - C # Stellen Sie sicher, Valid Enum Werte -. zukunfts~~POS=TRUNC Methode )

Im Hinblick auf das, unten ist, wie ich nun dieses Problem nähern würde (einschließlich impliziter Konvertierung zu / 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 ist, dass Sie alles bekommen, was Sie von der ENUM haben würde, aber der Code ist jetzt viel flexibler, so sollten Sie verschiedene Aktionen auf dem Wert von Question Basis durchführen müssen, können Sie Logik in Question setzen sich ( dh in der OO Mode bevorzugt) zu setzen viele Case-Anweisungen in Ihrem Code gegen jedes Szenario in Angriff zu nehmen.

NB: Antwort aktualisiert 2018.04.27 Verwendung von C # 6 Merkmale zu machen; d.h. Erklärung Ausdrücke und Lambda-Ausdruck Körperdefinitionen. Siehe Revisionsgeschichte ursprünglichen Code. Dies hat den Vorteil, dass die Definition etwas weniger ausführlich; die über diese Antwort Ansatz einer der wichtigsten Beschwerden gewesen war.

Wenn Sie eine ganze Zahl für den ENUM-Wert erhalten mag, die in einer Variablen gespeichert ist, weicht der Typ Question würde, zum Beispiel in einem Verfahren zu verwenden, können Sie dies einfach tun, die ich in diesem Beispiel schrieb: 

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

Damit wird der Fenstertitel zu 4 ändern, da die Variable Geselecteerd Talen.Nederlands ist. Wenn ich es wieder ändern die Methode Talen.Portugees und rufen, wird der Text auf 3 ändern.

Ich hatte eine harte Zeit, diese einfache Lösung im Internet zu finden, und ich kann ihn nicht finden, so dass ich teste etwas und fand diese heraus. Hoffe das hilft. ;)

Um ein ENUM-Wert vorhanden ist sicherzustellen, und dann analysieren, können Sie auch die folgende tun können. 

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

Ich hoffe, das hilft.

Vielleicht habe ich es aber hat jemand versucht, eine einfache generische Erweiterungsmethode. Dies funktioniert gut für mich. Sie können die Typumwandlung in Ihrem API auf diese Weise vermeiden, aber letztlich kommt es zu einer Änderung Typ Betrieb. Dies ist ein gutes Beispiel für die Programmierung Roselyn der Compiler hat eine GetValue Methode für Sie. 

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

Eine weitere Möglichkeit, es zu tun: 

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

Wird ergeben: 

Name: Role, Value: 2

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

... ist eine feine Erklärung an.

Sie haben das Ergebnis zu werfen wie so int: 

int Question = (int)QuestionType.Role

Ansonsten ist der Typ noch QuestionType.

Dieses Maß an Strenge ist die C # Art und Weise.

Eine Alternative ist es, eine Klassendeklaration zu verwenden, anstatt: 

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 erklären, aber Sie müssen es nicht in Code werfen: 

int Question = QuestionType.Role

Alternativ können Sie sich wohler mit Visual Basic fühlen, die in vielen Bereichen für diese Art von Erwartung gerecht wird.

Sie können dies durch die Implementierung einer Erweiterungsmethode , um Ihren definierten Enum-Typen: 

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

Das simplify bekommen int Wert der aktuellen Enum-Wert: 

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

oder 

int value = Question.Role.getNumberValue();

int number = Question.Role.GetHashCode();

number sollte den Wert 2 haben.

Wie über eine Erweiterungsmethode statt: 

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

Und die Nutzung ist etwas hübschere: 

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

My fav hackt mit int oder kleinen Aufzählungen: 

GetHashCode();

Für eine Enum 

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

Dieses 

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

Hinweis: Funktioniert nicht für Aufzählungen auf der Grundlage lang

Im Anschluss an 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;
}

Da Aufzählungen können mit mehreren primitiven Typen deklariert werden, eine generische Erweiterungsmethode jeden Aufzählungstyp werfen kann nützlich 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;

Das Beispiel Ich mag würde ‚bekommen‚int vorschlagen‘Wert von ENUM ist‘ 

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

int answer = (int)Sample.Book;

jetzt die Antwort wird 1 sein.

Ich hoffe, das jemand helfen könnte.

Die einfachste Lösung, die ich denken kann, ist die Get(int) Methode wie folgt Überlastung: 

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

wo [modifiers] können im Allgemeinen als für Get(int) Verfahren gleich sein. Wenn Sie können nicht die Questions Klasse bearbeiten oder aus irgendeinem Grund nicht wollen, können Sie die Methode Überlastung durch eine Erweiterung zu schreiben: 

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

Versuchen Sie dieses statt convert Enum in int: 

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

In Vb. Es sollte sein 

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

Private value As Integer = CInt(Question.Role)

ich ein bisschen spät, um das Spiel, aber ich kam mit dieser Erweiterung Methode auf, die aktuellen Sprachfunktionen enthält. Durch die Verwendung von dynamischen, brauche ich nicht die Art diesen eine generische Methode und geben Sie zu machen, das den Aufruf einfacher und konsistent hält. Bitte lassen Sie mich wissen, wenn ich etwas getan habe falsch: 

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

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

Wird in value == 2 zur Folge haben.

  

Dies gilt allerdings nur, wenn die Enum innerhalb eines int passen

Versuchen Sie folgendes: 

int value = YourEnum.ToString("D");
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top