Convertir une chaîne en un enum en C#

Quel est le meilleur moyen de convertir une chaîne de valeur de l'énumération en C#?

J'ai un select HTML balise contenant les valeurs d'une énumération. Lorsque la page est affichée, je veux choisir la valeur (qui sera sous la forme d'une chaîne de caractères) et de le convertir à la valeur de l'énumération.

Dans un monde idéal, je pourrais faire quelque chose comme ceci:

StatusEnum MyStatus = StatusEnum.Parse("Active");

mais ce n'est pas un code valide.

InformationsquelleAutor Ben Mills | 2008-08-19
  1. 1220

    Dans .NET de Base et .NET >4 il y a un générique de la méthode d'analyse:

    Enum.TryParse("Active", out StatusEnum myStatus);

    Cela inclut aussi C#7 nouvelles inline out variables, si ce n'est l'essai, l'analyse, la conversion explicite de type enum et initialise+remplit la myStatus variable.

    Si vous avez accès à C#7 et la dernière .NET c'est le meilleur moyen.

    Réponse Originale À Cette Question

    Dans .NET c'est plutôt moche (jusqu'à 4 ou ci-dessus):

    StatusEnum MyStatus = (StatusEnum) Enum.Parse(typeof(StatusEnum), "Active", true);

    J'ai tendance à simplifier ce avec:

    public static T ParseEnum<T>(string value)
{
    return (T) Enum.Parse(typeof(T), value, true);
}

    Alors je peux le faire:

    StatusEnum MyStatus = EnumUtil.ParseEnum<StatusEnum>("Active");

    Une option proposée dans les commentaires, c'est pour ajouter une extension, qui est assez simple:

    public static T ToEnum<T>(this string value)
{
    return (T) Enum.Parse(typeof(T), value, true);
}

StatusEnum MyStatus = "Active".ToEnum<StatusEnum>();

    Enfin, vous voudrez peut-être avoir un défaut enum à utiliser si la chaîne ne peut pas être analysée:

    public static T ToEnum<T>(this string value, T defaultValue) 
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    T result;
    return Enum.TryParse<T>(value, true, out result) ? result : defaultValue;
}

    Qui fait de cet appel:

    StatusEnum MyStatus = "Active".ToEnum(StatusEnum.None);

    Cependant, je serais prudent, l'ajout d'une méthode d'extension de ce type à string sous (sans l'espace de noms de contrôle), il apparaîtra sur toutes les instances de string s'ils sont titulaires d'un enum ou pas (donc 1234.ToString().ToEnum(StatusEnum.None) serait valide, mais pas de sens) . Il est souvent préférable d'éviter de l'encombrer de Microsoft de base des classes avec des méthodes supplémentaires qui s'appliquent seulement dans des contextes moins que l'ensemble de votre équipe de développement a une très bonne compréhension de ce que ces extensions ne.

    • Si performace est important (ce qui est toujours le cas) chk réponse donnée par Mckenzieg1 ci-dessous : stackoverflow.com/questions/16100/...
    • est droit sur @McKenzieG1 réponse, mais il n'est pas TOUJOURS important. Par exemple, il serait inutile de la micro-optimisation à vous soucier de l'enum de l'analyse si vous faisiez une DB à appeler pour chaque analyse.
    • faire une extension de la méthode et ce sera parfait
    • Je ne pense pas qu'une extension est approprié ici - c'est un peu un cas particulier, et d'une extension s'appliquerait à tous chaîne de caractères. Si vous avez vraiment envie de le faire même si ce serait un banal changement.
    • c'était mon avis parce que les classes statiques sont très difficiles à retenir, mais on peut toujours se souvient d'une méthode d'extension! et oui, le paramètre n'a besoin d'une <code>cette</code> mot-clé
    • Que diriez-Enum.TryParse?
    • J'ai ajouté une extension de la version, avec un avertissement.
    • Ajout d'une variante qui utilise TryParse.
    • Pourrais-tu élaborer un peu sur ce qui serait contre une méthode d'extension de cette? Je ne comprends pas quel est le problème serait.
    • oui - en règle générale, vous devez être très prudent à l'extension de Microsoft intégré dans les objets, surtout les plus courantes, comme object ou string que sans un espace de noms de contrôler ce sera la cause de votre méthode d'extension pour être visible sur chaque instance de l'ensemble de votre base de code. Ce n'est pas un problème lorsque la méthode est toujours approprié (par exemple .Trim() ou .Split()), mais un enum analyser ne va s'appliquer que lorsque la chaîne est prévu de tenir un enum. Une ou deux méthodes de ce genre sont sans doute très bien, mais vous pouvez vous retrouver avec des charges de confusion sur les grands projets.
    • Ok, mais qui ne s'applique que si l'espace de noms est inclus dans un droit d'usage? Donc, namespace SomeNameSpace.Extensions.Strings ne serait pas causer des problèmes?
    • oui, exactement - c'est ce que je veux dire par espace de noms de contrôle. Vous pouvez mettre ces extensions de noms de l'opt-in à eux étant disponible - un bilan de la commodité et le code de la normalisation qui dépend beaucoup de votre équipe de développement.
    • très agréable. vous avez besoin d'un T : struct dans votre dernier exemple.
    • cela n'aide pas vraiment - ce que nous avons vraiment besoin, c'est un générique enum contrainte: stackoverflow.com/q/7244/905
    • Je ne vois pas l'extension mal du tout. Avec construit dans les classes, etc.. vous pouvez écrire du code qui n'a pas de sens indépendamment des extensions. Pour utiliser cette extension, vous avez une aide pour comprendre et ensuite l'utiliser effectivement. Même dans les cas qui suivent l'a suggéré l'utilisation d'extensions dans ces commentaires que vous souhaitez toujours besoin d'avoir la gestion d'erreur en cas de mauvaise saisie, je ne vois pas en quoi cela est différent. Évidemment, vous mettez tout et toutes les extensions que vous écrivez qui s'étendent des classes de base dans votre propre espace de noms.
    • Je n'ai pas dit que c'était mauvais, juste quelque chose que vous devez être prudent avec - une extension semble s'appliquent à toutes les occurrences d'une chaîne, mais n'a de sens que dans un sous-ensemble de contextes. Vous pouvez gérer des entrées erronées, mais c'est une case à l'encontre d'un moment de la compilation problème. Par exemple SubString() s'applique toujours à l'encontre d'une chaîne de caractères, et au moment de l'exécution de vérifier si la chaîne est trop courte pour les indices fournis, mais ToEnum peut ou peut ne pas s'appliquer en fonction de ce que vous mettez dans. Ce n'est pas mauvais ou de blocage en tant que tels, juste quelque chose à être prudent avec.
    • Je vois ce que tu veux dire, peut-être que si il a été appelé TryToEnum (), alors il serait plus explicite et de le rendre clair qu'il risque d'échouer. Essentiellement des extensions sont compilateur de sucre, une méthode d'extension .ToEnum() n'est pas différent Enum.Parse() - la chaîne de paramètre ne peut pas être garantie à convertibles.
    • Comme mentionné par @bbrik vous devez ajouter T : struct dans votre dernier exemple, pour que le compilateur de l'accepter.
    • Je veux utiliser la méthode d'extension où une valeur par défaut peut être fourni. J'ai copié et collé à votre méthode d'extension, mais recevez le message d'erreur: Le type " T " doit être un non nullable type de valeur afin de l'utiliser comme paramètre 'TEnum" dans le générique du type ou de la méthode 'Système.Enum.TryParse<TEnum>(string, bool, hors TEnum)'
    • regardez le commentaire ci-dessus. public static T ToEnum<T>(this string value, T defaultValue) where T : struct
    • très joli, Bravo
    • where T : struct, IComparable est nécessaire pour être ajouté à la fin de l'extension de la méthode de définition.
    • grand homme
    • Il devrait être comme suit: StatusEnum myStatus; Enum.TryParse("Active", sur myStatus);
    • en C#7 et ci-dessus, vous n'avez pas besoin de déclarer la enum tout d'abord, vous pouvez faire if(Enum.TryParse("Active", out StatusEnum myStatus)) { /* use myStatus */ }

    InformationsquelleAutor Keith
  2. 287

    Utilisation Enum.TryParse<T>(String, T) (≥ .NET 4.0):

    StatusEnum myStatus;
Enum.TryParse("Active", out myStatus);

    Il est possible de simplifier encore plus loin avec le C# 7.0 paramètre de type inline:

    Enum.TryParse("Active", out StatusEnum myStatus);
    • Ajoutez le milieu paramètre booléen pour la casse et c'est le plus sûr et le plus élégant de la solution, et de loin.
    • Allez, combien de vous avez mis en œuvre cette réponse sélectionnée à partir de 2008 à seulement faites défiler vers le bas et de trouver ce qui est le mieux (moderne) de la réponse.
    • Bon points supplémentaires ici: stackoverflow.com/a/34267134/541420
    • Je préfère le 2008 réponse.
    • Je n'ai pas l'obtenir. Parse jette exposé des exceptions pour ce qui s'est passé avec la conversion (valeur a été null, vide ou pas de constante enum), ce qui est nettement mieux que TryParses'boolean valeur de retour (qui supprime le béton erreur)
    InformationsquelleAutor Erwin Mayer
  3. 175

    Noter que la performance de l'Enum.Parse() est terrible, parce qu'il est mis en œuvre par la réflexion. (La même chose est vraie de l'Enum.ToString, qui va dans l'autre sens.)

    Si vous avez besoin de convertir des chaînes en Enums des performances sensibles à code, votre meilleur pari est de créer un Dictionary<String,YourEnum> au démarrage et à l'utiliser pour faire vos conversions.

    • J'ai mesuré 3ms pour convertir une chaîne en un Enum sur la première manche, sur un ordinateur de bureau. (Juste pour illustrer le niveau de awfullness).
    • Wow 3ms est un ordre de grandeur de terrible
    • pouvez-vous ajouter un exemple de code autour de cela, de sorte que nous avons une idée sur comment remplacer et à utiliser
    • ici nous allons dotnetfiddle.net/sDEvpT
    InformationsquelleAutor McKenzieG1
  4. 82

    Vous êtes à la recherche pour Enum.Analyser.

    SomeEnum enum = (SomeEnum)Enum.Parse(typeof(SomeEnum), "EnumValue");
    InformationsquelleAutor DavidWhitney
  5. 26

    Vous pouvez utiliser les méthodes d'extension maintenant:

    public static T ToEnum<T>(this string value, bool ignoreCase = true)
{
    return (T) Enum.Parse(typeof (T), value, ignoreCase);
}

    Et vous pouvez les appeler par le code ci-dessous (ici, FilterType est un type enum):

    FilterType filterType = type.ToEnum<FilterType>();
    • J'ai mis à jour ce à prendre la valeur de l'objet et de le jeter à la chaîne à l'intérieur de cette méthode. De cette façon, je peux prendre une valeur int .ToEnum au lieu de cordes.
    • Je dirais que c'est une idée horrible cause de cette extension méthode s'applique à la tous types d'objet. Deux méthodes d'extension, une chaîne et un int, serait plus propre et plus sûr à mon avis.
    • c'est vrai. La seule raison pour laquelle je l'ai fait c'est parce que notre code est utilisé à l'intérieur uniquement et je voulais éviter d'écrire 2 extensions. Et puisque le seul moment où nous convertir Enum est avec string ou int, je ne le voyais pas être un problème autrement.
    • Interne ou pas, je suis toujours la maintenance et l'utilisation de mon code 😛 je serais ennuyé si je me suis levé un ToEnum dans chaque menu intellisense, et comme tu le dis, depuis le temps que vous convertir un enum est de string ou int, vous pouvez être sûr que vous aurez seulement besoin de ces deux méthodes. Et les deux méthodes ne sont pas beaucoup plus d'un, surtout quand ils sont petits et de l'utilitaire de type 😛
    InformationsquelleAutor Foyzul Karim
  6. 16
    object Enum.Parse(System.Type enumType, string value, bool ignoreCase);

    Donc si vous aviez un enum nommé humeur, il ressemblerait à ceci:

       enum Mood
   {
      Angry,
      Happy,
      Sad
   } 

   //...
   Mood m = (Mood) Enum.Parse(typeof(Mood), "Happy", true);
   Console.WriteLine("My mood is: {0}", m.ToString());
    • brillant réponse !
    InformationsquelleAutor brendan
  7. 16

    ATTENTION:

    enum Example
{
    One = 1,
    Two = 2,
    Three = 3
}

    Enum.(Try)Parse() accepte plusieurs, séparés par des virgules, des arguments, et les combine avec des binaires "ou"|. Vous ne pouvez pas désactiver cette et à mon avis vous presque jamais le souhaitez.

    var x = Enum.Parse("One,Two"); //x is now Three

    Même si Three n'a pas été défini, x voudrais quand même valeur int 3. C'est encore pire: Enum.Parse() peut vous donner une valeur qui n'est pas encore défini pour l'enum!

    Je ne voudrais pas vivre les conséquences d'utilisateurs, de gré ou de force, le déclenchement de ce comportement.

    En outre, comme mentionné par d'autres, les performances sont moins qu'idéales pour les grandes enums, à savoir linéaire en le nombre de valeurs possibles.

    Je suggère ce qui suit:

        public static bool TryParse<T>(string value, out T result)
        where T : struct
    {
        var cacheKey = "Enum_" + typeof(T).FullName;

        //[Use MemoryCache to retrieve or create&store a dictionary for this enum, permanently or temporarily.
        //[Implementation off-topic.]
        var enumDictionary = CacheHelper.GetCacheItem(cacheKey, CreateEnumDictionary<T>, EnumCacheExpiration);

        return enumDictionary.TryGetValue(value.Trim(), out result);
    }

    private static Dictionary<string, T> CreateEnumDictionary<T>()
    {
        return Enum.GetValues(typeof(T))
            .Cast<T>()
            .ToDictionary(value => value.ToString(), value => value, StringComparer.OrdinalIgnoreCase);
    }
    • En fait, c'est très utile de savoir que Enum.(Try)Parse accepts multiple, comma-separated arguments, and combines them with binary 'or'. Signifie que vous pouvez définir vos valeurs enum comme des puissances de 2 et vous avez une façon très simple d'analyser plusieurs boolean drapeaux, par exemple. "UseSSL,NoRetries," Sync". En fait, c'est sans doute ce à quoi il a été conçu.
    InformationsquelleAutor Timo
  8. 15

    Enum.Analyser est votre ami:

    StatusEnum MyStatus = (StatusEnum)Enum.Parse(typeof(StatusEnum), "Active");
    InformationsquelleAutor tags2k
  9. 11

    Vous pouvez étendre la accepté de répondre avec une valeur par défaut pour éviter les exceptions:

    public static T ParseEnum<T>(string value, T defaultValue) where T : struct
{
    try
    {
        T enumValue;
        if (!Enum.TryParse(value, true, out enumValue))
        {
            return defaultValue;
        }
        return enumValue;
    }
    catch (Exception)
    {
        return defaultValue;
    }
}

    Puis vous l'appeler comme:

    StatusEnum MyStatus = EnumUtil.ParseEnum("Active", StatusEnum.None);
    • Je n'aime pas les valeurs par défaut. Elle peut conduire à des résultats imprévisibles.
    • quand sera-ce jamais lever une exception?
    • si votre chaîne de valeur n'est pas une valeur de votre enum.
    • Bonne Solution pour mon problème, Merci...
    InformationsquelleAutor Nelly
  10. 8

    Nous ne pouvions pas assumer parfaitement valable d'entrée, et est allé avec cette variation de @Keith réponse:

    public static TEnum ParseEnum<TEnum>(string value) where TEnum : struct
{
    TEnum tmp; 
    if (!Enum.TryParse<TEnum>(value, true, out tmp))
    {
        tmp = new TEnum();
    }
    return tmp;
}
    InformationsquelleAutor gap
  11. 7
    //str.ToEnum<EnumType>()
T static ToEnum<T>(this string str) 
{ 
    return (T) Enum.Parse(typeof(T), str);
}
    InformationsquelleAutor Mark Cidade
  12. 5

    Analyse de la chaîne de TEnum sans try/catch et sans TryParse() la méthode de .NET 4.5

    ///<summary>
///Parses string to TEnum without try/catch and .NET 4.5 TryParse()
///</summary>
public static bool TryParseToEnum<TEnum>(string probablyEnumAsString_, out TEnum enumValue_) where TEnum : struct
{
    enumValue_ = (TEnum)Enum.GetValues(typeof(TEnum)).GetValue(0);
    if(!Enum.IsDefined(typeof(TEnum), probablyEnumAsString_))
        return false;

    enumValue_ = (TEnum) Enum.Parse(typeof(TEnum), probablyEnumAsString_);
    return true;
}
    • Vous devez fournir une description de votre code.
    • S'il est nécessaire de faire une description si le code contient déjà une description? Ok, je l'ai fait 🙂
    • Merci mec, c'était bien.
    InformationsquelleAutor jite.gs
  13. 3

    Super simple code à l'aide de TryParse:

    var value = "Active";

StatusEnum status;
if (!Enum.TryParse<StatusEnum>(value, out status))
    status = StatusEnum.Unknown;
    InformationsquelleAutor Brian Rice
  14. 2

    J'aime la méthode d'extension de la solution..

    namespace System
{
    public static class StringExtensions
    {

        public static bool TryParseAsEnum<T>(this string value, out T output) where T : struct
        {
            T result;

            var isEnum = Enum.TryParse(value, out result);

            output = isEnum ? result : default(T);

            return isEnum;
        }
    }
}

    Ici en dessous de ma mise en œuvre avec des tests.

    using static Microsoft.VisualStudio.TestTools.UnitTesting.Assert;
using static System.Console;

private enum Countries
    {
        NorthAmerica,
        Europe,
        Rusia,
        Brasil,
        China,
        Asia,
        Australia
    }

   [TestMethod]
        public void StringExtensions_On_TryParseAsEnum()
        {
            var countryName = "Rusia";

            Countries country;
            var isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsTrue(isCountry);
            AreEqual(Countries.Rusia, country);

            countryName = "Don't exist";

            isCountry = countryName.TryParseAsEnum(out country);

            WriteLine(country);

            IsFalse(isCountry);
            AreEqual(Countries.NorthAmerica, country); //the 1rst one in the enumeration
        }
    InformationsquelleAutor alhpe
  15. 1
    public static T ParseEnum<T>(string value)            //function declaration  
{
    return (T) Enum.Parse(typeof(T), value);
}

Importance imp = EnumUtil.ParseEnum<Importance>("Active");   //function call

    ====================Un Programme Complet====================

    using System;

class Program
{
    enum PetType
    {
    None,
    Cat = 1,
    Dog = 2
    }

    static void Main()
    {

    //Possible user input:
    string value = "Dog";

    //Try to convert the string to an enum:
    PetType pet = (PetType)Enum.Parse(typeof(PetType), value);

    //See if the conversion succeeded:
    if (pet == PetType.Dog)
    {
        Console.WriteLine("Equals dog.");
    }
    }
}
-------------
Output

Equals dog.
    InformationsquelleAutor Rae Lee
  16. 1

    J'ai utilisé de la classe (fortement typées version de Enum avec l'analyse et des améliorations de performances). Je l'ai trouvé sur GitHub, et il doit travailler pour .NET 3.5 trop. Il a une certaine surcharge de la mémoire car il tamponne un dictionnaire.

    StatusEnum MyStatus = Enum<StatusEnum>.Parse("Active");

    Le blog est Les Enums – Meilleure syntaxe, l'amélioration de la performance et de TryParse NET 3.5.

    Et le code:
    https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/System/EnumT.cs

    InformationsquelleAutor Patrik Lindström
  17. 1

    Pour la performance, ce qui pourrait aider:

        private static Dictionary<Type, Dictionary<string, object>> dicEnum = new Dictionary<Type, Dictionary<string, object>>();
    public static T ToEnum<T>(this string value, T defaultValue)
    {
        var t = typeof(T);
        Dictionary<string, object> dic;
        if (!dicEnum.ContainsKey(t))
        {
            dic = new Dictionary<string, object>();
            dicEnum.Add(t, dic);
            foreach (var en in Enum.GetValues(t))
                dic.Add(en.ToString(), en);
        }
        else
            dic = dicEnum[t];
        if (!dic.ContainsKey(value))
            return defaultValue;
        else
            return (T)dic[value];
    }
    InformationsquelleAutor Koray
  18. 1

    J'ai trouvé que le cas ici avec les valeurs de l'enum qui ont EnumMember valeur n'a pas été considéré. Donc, ici, nous allons:

    using System.Runtime.Serialization;

public static TEnum ToEnum<TEnum>(this string value, TEnum defaultValue) where TEnum : struct
{
    if (string.IsNullOrEmpty(value))
    {
        return defaultValue;
    }

    TEnum result;
    var enumType = typeof(TEnum);
    foreach (var enumName in Enum.GetNames(enumType))
    {
        var fieldInfo = enumType.GetField(enumName);
        var enumMemberAttribute = ((EnumMemberAttribute[]) fieldInfo.GetCustomAttributes(typeof(EnumMemberAttribute), true)).FirstOrDefault();
        if (enumMemberAttribute?.Value == value)
        {
            return Enum.TryParse(enumName, true, out result) ? result : defaultValue;
        }
    }

    return Enum.TryParse(value, true, out result) ? result : defaultValue;
}

    Et l'exemple de l'enum:

    public enum OracleInstanceStatus
{
    Unknown = -1,
    Started = 1,
    Mounted = 2,
    Open = 3,
    [EnumMember(Value = "OPEN MIGRATE")]
    OpenMigrate = 4
}
    InformationsquelleAutor isxaker
  19. 1

    Vous devez utiliser le protocole Enum.Analyser pour obtenir la valeur de l'objet de l'Enum, après cela, vous devez modifier la valeur de l'objet spécifique de la valeur d'enum. Casting à la valeur d'enum peut être par le biais de Convertir.ChangeType. S'il vous plaît avoir un oeil sur l'extrait de code suivant

    public T ConvertStringValueToEnum<T>(string valueToParse){
    return Convert.ChangeType(Enum.Parse(typeof(T), valueToParse, true), typeof(T));
}
    InformationsquelleAutor Bartosz Gawron
  20. 1

    Essayez cet exemple:

     public static T GetEnum<T>(string model)
    {
        var newModel = GetStringForEnum(model);

        if (!Enum.IsDefined(typeof(T), newModel))
        {
            return (T)Enum.Parse(typeof(T), "None", true);
        }

        return (T)Enum.Parse(typeof(T), newModel.Result, true);
    }

    private static Task<string> GetStringForEnum(string model)
    {
        return Task.Run(() =>
        {
            Regex rgx = new Regex("[^a-zA-Z0-9 -]");
            var nonAlphanumericData = rgx.Matches(model);
            if (nonAlphanumericData.Count < 1)
            {
                return model;
            }
            foreach (var item in nonAlphanumericData)
            {
                model = model.Replace((string)item, "");
            }
            return model;
        });
    }

    Dans cet exemple, vous pouvez envoyer toutes les chaînes, et de définir votre Enum. Si votre Enum avait des données que vous avez voulu, de retour en tant que Enum type.

    • Vous l'écrasez newModel sur chaque ligne, donc si il contient des tirets, il ne sera pas remplacé. Aussi, vous n'avez pas à vérifier si la chaîne contient quoi que ce soit, vous pouvez simplement appeler Replace de toute façon: var newModel = model.Replace("-", "").Replace(" ", "");
    • Oui, nous pouvons créer une méthode de suppression de caractère non alphanumérique.
    InformationsquelleAutor AmirReza-Farahlagha
  21. 0
            <Extension()>
    Public Function ToEnum(Of TEnum)(ByVal value As String, ByVal defaultValue As TEnum) As TEnum
        If String.IsNullOrEmpty(value) Then
            Return defaultValue
        End If

        Return [Enum].Parse(GetType(TEnum), value, True)
    End Function
    InformationsquelleAutor AHMED RABEE
  22. 0
    public TEnum ToEnum<TEnum>(this string value, TEnum defaultValue){
if (string.IsNullOrEmpty(value))
    return defaultValue;

return Enum.Parse(typeof(TEnum), value, true);}
    InformationsquelleAutor AHMED RABEE