web-dev-qa-db-fra.com

Comment obtenir une valeur enum par string ou int

Comment puis-je obtenir la valeur enum si j'ai la chaîne enum ou la valeur enum int. Par exemple: si j'ai un enum comme suit:

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

et dans une variable de chaîne, j'ai la valeur "value1" comme suit:

string str = "Value1"

ou dans une variable int j'ai la valeur 2 comme

int a = 2;

comment puis-je obtenir l'instance d'enum? Je veux une méthode générique où je peux fournir l'énum et ma chaîne d'entrée ou ma valeur int pour obtenir l'instance d'énum.

c#enums
69
Abhishek Gahlout

Non, vous ne voulez pas de méthode générique. C'est beaucoup plus facile:

MyEnum enum = (MyEnum)myInt;

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

Je pense que ce sera aussi plus rapide.

126
Kendall Frey

Il existe de nombreuses façons de le faire, mais si vous voulez un exemple simple, cela ira. Il doit simplement être amélioré avec le codage défensif nécessaire pour vérifier la sécurité du type, l'analyse syntaxique invalide, etc.

    /// <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>();
    }
20
David Spenard

Cela pourrait être beaucoup plus simple si vous utilisez les méthodes TryParse ou Parse et ToObject.

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

Comme l'a noté @chrfin dans les commentaires, vous pouvez très facilement en faire une méthode d'extension en ajoutant simplement this avant le type de paramètre, ce qui peut être pratique.

13
Sriram Sakthivel

Voici la méthode en C # pour obtenir la valeur enum par chaîne

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

Voici la méthode en C # pour obtenir la valeur enum par int.

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

Si j'ai un enum comme suit:

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

alors je peux utiliser les méthodes ci-dessus

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

J'espère que cela aidera.

4
Abhishek Gahlout

Je pense que vous avez oublié la définition de type générique:

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

et vous pouvez l’améliorer pour le rendre plus pratique, par exemple:

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

alors vous pouvez faire:

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

À partir de la base de données SQL, obtenez l'énumération suivante:

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

Essayez quelque chose comme ça

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

Donc tu peux faire

TestEnum en = "Value1".GetMyEnum();
1
huMpty duMpty

Essayez simplement ceci

C'est une autre manière

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

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

c'est un commentaire pour votre article

1
user3559224

Voici un exemple pour obtenir une chaîne/valeur

    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
0
Daniel Jeong