So erhalten Sie einen Aufzählungswert per Zeichenfolge oder int

Wie kann ich den Enum-Wert erhalten, wenn ich den Enum-String oder den Enum-Int-Wert habe? zB: Wenn ich eine Aufzählung wie folgt habe:

public enum TestEnum
{
    Value1 = 1,
    Value2 = 2,
    Value3 = 3
}

und in einer Stringvariablen habe ich den Wert "value1" wie folgt:

string str = "Value1" 

oder in einer int Variablen habe ich den Wert 2 wie

int a = 2;

Wie kann ich die Instanz von enum erhalten? Ich möchte eine generische Methode, bei der ich die Aufzählung und meine Eingabezeichenfolge oder den int-Wert angeben kann, um die Aufzählungsinstanz abzurufen.

Nein, Sie möchten keine generische Methode. Das ist viel einfacher:

MyEnum myEnum = (MyEnum)myInt;

MyEnum myEnum = (MyEnum)Enum.Parse(typeof(MyEnum), myString);

Ich denke es wird auch schneller.

Es gibt zahlreiche Möglichkeiten, dies zu tun. Wenn Sie jedoch ein einfaches Beispiel wünschen, reicht dies aus. Es muss nur mit der erforderlichen defensiven Codierung erweitert werden, um die Typensicherheit und ungültige Analyse usw. zu überprüfen.

    /// <summary>
    /// Extension method to return an enum value of type T for the given string.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this string value)
    {
        return (T) Enum.Parse(typeof(T), value, true);
    }

    /// <summary>
    /// Extension method to return an enum value of type T for the given int.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="value"></param>
    /// <returns></returns>
    public static T ToEnum<T>(this int value)
    {
        var name = Enum.GetName(typeof(T), value);
        return name.ToEnum<T>();
    }

Könnte viel einfacher sein, wenn Sie TryParseoder Parseund ToObjectMethoden verwenden.

public static class EnumHelper
{
    public static  T GetEnumValue<T>(string str) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }
        T val;
        return Enum.TryParse<T>(str, true, out val) ? val : default(T);
    }

    public static T GetEnumValue<T>(int intValue) where T : struct, IConvertible
    {
        Type enumType = typeof(T);
        if (!enumType.IsEnum)
        {
            throw new Exception("T must be an Enumeration type.");
        }

        return (T)Enum.ToObject(enumType, intValue);
    }
}

Wie von @chrfin in den Kommentaren erwähnt, können Sie es sehr einfach zu einer Erweiterungsmethode machen, indem Sie thisvor dem Parametertyp hinzufügen, was praktisch sein kann.

Ich denke, Sie haben die generische Typdefinition vergessen:

public T GetEnumValue<T>(int intValue) where T : struct, IConvertible // <T> added

und Sie können es verbessern, um am bequemsten zu sein, wie z.

public static T ToEnum<T>(this string enumValue) : where T : struct, IConvertible
{
    return (T)Enum.Parse(typeof(T), enumValue);
}

dann können Sie tun:

TestEnum reqValue = "Value1".ToEnum<TestEnum>();

Versuchen Sie so etwas

  public static TestEnum GetMyEnum(this string title)
        {    
            EnumBookType st;
            Enum.TryParse(title, out st);
            return st;          
         }

So können Sie tun

TestEnum en = "Value1".GetMyEnum();

Aus der SQL-Datenbank erhalten Sie eine Aufzählung wie:

SqlDataReader dr = selectCmd.ExecuteReader();
while (dr.Read()) {
   EnumType et = (EnumType)Enum.Parse(typeof(EnumType), dr.GetString(0));
   ....         
}

Probieren Sie es einfach aus

Es ist ein anderer Weg

public enum CaseOriginCode
{
    Web = 0,
    Email = 1,
    Telefoon = 2
}

public void setCaseOriginCode(string CaseOriginCode)
{
    int caseOriginCode = (int)(CaseOriginCode)Enum.Parse(typeof(CaseOriginCode), CaseOriginCode);
}

Es folgt die Methode in C #, um den Aufzählungswert per Zeichenfolge abzurufen

///
/// Method to get enumeration value from string value.
///
///
///

public T GetEnumValue<T>(string str) where T : struct, IConvertible
{
    if (!typeof(T).IsEnum)
    {
        throw new Exception("T must be an Enumeration type.");
    }
    T val = ((T[])Enum.GetValues(typeof(T)))[0];
    if (!string.IsNullOrEmpty(str))
    {
        foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
        {
            if (enumValue.ToString().ToUpper().Equals(str.ToUpper()))
            {
                val = enumValue;
                break;
            }
        }
    }

    return val;
}

Es folgt die Methode in C #, um den Aufzählungswert von int zu erhalten.

///
/// Method to get enumeration value from int value.
///
///
///

public T GetEnumValue<T>(int intValue) where T : struct, IConvertible
{
    if (!typeof(T).IsEnum)
    {
        throw new Exception("T must be an Enumeration type.");
    }
    T val = ((T[])Enum.GetValues(typeof(T)))[0];

    foreach (T enumValue in (T[])Enum.GetValues(typeof(T)))
    {
        if (Convert.ToInt32(enumValue).Equals(intValue))
        {
            val = enumValue;
            break;
        }             
    }
    return val;
}

Wenn ich eine Aufzählung wie folgt habe:

public enum TestEnum
{
    Value1 = 1,
    Value2 = 2,
    Value3 = 3
}

dann kann ich die oben genannten Methoden als verwenden

TestEnum reqValue = GetEnumValue<TestEnum>("Value1");  // Output: Value1
TestEnum reqValue2 = GetEnumValue<TestEnum>(2);        // OutPut: Value2

Hoffe das wird helfen.

Hier ist ein Beispiel, um einen String / Wert zu erhalten

    public enum Suit
    {
        Spades = 0x10,
        Hearts = 0x11,
        Clubs = 0x12,
        Diamonds = 0x13
    }

    private void print_suit()
    {
        foreach (var _suit in Enum.GetValues(typeof(Suit)))
        {
            int suitValue = (byte)(Suit)Enum.Parse(typeof(Suit), _suit.ToString());
            MessageBox.Show(_suit.ToString() + " value is 0x" + suitValue.ToString("X2"));
        }
    }

    Result of Message Boxes
    Spade value is 0x10
    Hearts value is 0x11
    Clubs value is 0x12
    Diamonds value is 0x13

Sie können dazu die folgende Methode verwenden:

public static Output GetEnumItem<Output, Input>(Input input)
    {
        //Output type checking...
        if (typeof(Output).BaseType != typeof(Enum))
            throw new Exception("Exception message...");

        //Input type checking: string type
        if (typeof(Input) == typeof(string))
            return (Output)Enum.Parse(typeof(Output), (dynamic)input);

        //Input type checking: Integer type
        if (typeof(Input) == typeof(Int16) ||
            typeof(Input) == typeof(Int32) ||
            typeof(Input) == typeof(Int64))

            return (Output)(dynamic)input;

        throw new Exception("Exception message...");
    }

Hinweis: Diese Methode ist nur ein Beispiel und kann verbessert werden.