Comment TryParse pour la valeur Enum?

Je veux écrire une fonction qui peut valider une valeur donnée (passée sous forme de chaîne) par rapport aux valeurs possibles d'un enum. Dans le cas d'une correspondance, il doit renvoyer l'instance enum; sinon, il doit renvoyer une valeur par défaut.

La fonction ne peut pas utiliser en interne try/ catch, ce qui exclut l'utilisation Enum.Parse, qui lève une exception quand un argument non valide est donné.

Je voudrais utiliser quelque chose comme une TryParsefonction pour implémenter ceci:

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
   object enumValue;
   if (!TryParse (typeof (TEnum), strEnumValue, out enumValue))
   {
       return defaultValue;
   }
   return (TEnum) enumValue;
}

Comme d'autres l'ont dit, vous devez mettre en œuvre le vôtre TryParse. Simon Mourier fournit une mise en œuvre complète qui s'occupe de tout.

Si vous utilisez des énumérations de champs de bits (c'est-à-dire des indicateurs), vous devez également gérer une chaîne comme "MyEnum.Val1|MyEnum.Val2"qui est une combinaison de deux valeurs d'énumération. Si vous appelez simplement Enum.IsDefinedavec cette chaîne, il retournera false, même s'il le Enum.Parsegère correctement.

Mettre à jour

Comme mentionné par Lisa et Christian dans les commentaires, Enum.TryParseest maintenant disponible pour C # dans .NET4 et plus.

Documents MSDN

Enum.IsDefined fera avancer les choses. Ce n'est peut-être pas aussi efficace qu'un TryParse, mais cela fonctionnera sans traitement d'exception.

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue)
{
    if (!Enum.IsDefined(typeof(TEnum), strEnumValue))
        return defaultValue;

    return (TEnum)Enum.Parse(typeof(TEnum), strEnumValue);
}

A noter: une TryParseméthode a été ajoutée dans .NET 4.0.

Voici une implémentation personnalisée de EnumTryParse. Contrairement à d'autres implémentations courantes, il prend également en charge les énumérations marquées avec l' Flagsattribut.

    /// <summary>
    /// Converts the string representation of an enum to its Enum equivalent value. A return value indicates whether the operation succeeded.
    /// This method does not rely on Enum.Parse and therefore will never raise any first or second chance exception.
    /// </summary>
    /// <param name="type">The enum target type. May not be null.</param>
    /// <param name="input">The input text. May be null.</param>
    /// <param name="value">When this method returns, contains Enum equivalent value to the enum contained in input, if the conversion succeeded.</param>
    /// <returns>
    /// true if s was converted successfully; otherwise, false.
    /// </returns>
    public static bool EnumTryParse(Type type, string input, out object value)
    {
        if (type == null)
            throw new ArgumentNullException("type");

        if (!type.IsEnum)
            throw new ArgumentException(null, "type");

        if (input == null)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        input = input.Trim();
        if (input.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        string[] names = Enum.GetNames(type);
        if (names.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        Type underlyingType = Enum.GetUnderlyingType(type);
        Array values = Enum.GetValues(type);
        // some enums like System.CodeDom.MemberAttributes *are* flags but are not declared with Flags...
        if ((!type.IsDefined(typeof(FlagsAttribute), true)) && (input.IndexOfAny(_enumSeperators) < 0))
            return EnumToObject(type, underlyingType, names, values, input, out value);

        // multi value enum
        string[] tokens = input.Split(_enumSeperators, StringSplitOptions.RemoveEmptyEntries);
        if (tokens.Length == 0)
        {
            value = Activator.CreateInstance(type);
            return false;
        }

        ulong ul = 0;
        foreach (string tok in tokens)
        {
            string token = tok.Trim(); // NOTE: we don't consider empty tokens as errors
            if (token.Length == 0)
                continue;

            object tokenValue;
            if (!EnumToObject(type, underlyingType, names, values, token, out tokenValue))
            {
                value = Activator.CreateInstance(type);
                return false;
            }

            ulong tokenUl;
            switch (Convert.GetTypeCode(tokenValue))
            {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.SByte:
                    tokenUl = (ulong)Convert.ToInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;

                //case TypeCode.Byte:
                //case TypeCode.UInt16:
                //case TypeCode.UInt32:
                //case TypeCode.UInt64:
                default:
                    tokenUl = Convert.ToUInt64(tokenValue, CultureInfo.InvariantCulture);
                    break;
            }

            ul |= tokenUl;
        }
        value = Enum.ToObject(type, ul);
        return true;
    }

    private static char[] _enumSeperators = new char[] { ',', ';', '+', '|', ' ' };

    private static object EnumToObject(Type underlyingType, string input)
    {
        if (underlyingType == typeof(int))
        {
            int s;
            if (int.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(uint))
        {
            uint s;
            if (uint.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ulong))
        {
            ulong s;
            if (ulong.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(long))
        {
            long s;
            if (long.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(short))
        {
            short s;
            if (short.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(ushort))
        {
            ushort s;
            if (ushort.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(byte))
        {
            byte s;
            if (byte.TryParse(input, out s))
                return s;
        }

        if (underlyingType == typeof(sbyte))
        {
            sbyte s;
            if (sbyte.TryParse(input, out s))
                return s;
        }

        return null;
    }

    private static bool EnumToObject(Type type, Type underlyingType, string[] names, Array values, string input, out object value)
    {
        for (int i = 0; i < names.Length; i++)
        {
            if (string.Compare(names[i], input, StringComparison.OrdinalIgnoreCase) == 0)
            {
                value = values.GetValue(i);
                return true;
            }
        }

        if ((char.IsDigit(input[0]) || (input[0] == '-')) || (input[0] == '+'))
        {
            object obj = EnumToObject(underlyingType, input);
            if (obj == null)
            {
                value = Activator.CreateInstance(type);
                return false;
            }
            value = obj;
            return true;
        }

        value = Activator.CreateInstance(type);
        return false;
    }

En fin de compte, vous devez mettre en œuvre ceci autour de Enum.GetNames:

public bool TryParseEnum<T>(string str, bool caseSensitive, out T value) where T : struct {
    // Can't make this a type constraint...
    if (!typeof(T).IsEnum) {
        throw new ArgumentException("Type parameter must be an enum");
    }
    var names = Enum.GetNames(typeof(T));
    value = (Enum.GetValues(typeof(T)) as T[])[0];  // For want of a better default
    foreach (var name in names) {
        if (String.Equals(name, str, caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) {
            value = (T)Enum.Parse(typeof(T), name);
            return true;
        }
    }
    return false;
}

Notes complémentaires:

• Enum.TryParseest inclus dans .NET 4. Voir ici http://msdn.microsoft.com/library/dd991876(VS.100).aspx
• Une autre approche consisterait à encapsuler directement la Enum.Parsecapture de l'exception levée en cas d'échec. Cela pourrait être plus rapide lorsqu'une correspondance est trouvée, mais sera probablement plus lent sinon. En fonction des données que vous traitez, cela peut ou non être une nette amélioration.

EDIT: Je viens de voir une meilleure implémentation à ce sujet, qui met en cache les informations nécessaires: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5

Basé sur .NET 4.5

Exemple de code ci-dessous

using System;

enum Importance
{
    None,
    Low,
    Medium,
    Critical
}

class Program
{
    static void Main()
    {
    // The input value.
    string value = "Medium";

    // An unitialized variable.
    Importance importance;

    // Call Enum.TryParse method.
    if (Enum.TryParse(value, out importance))
    {
        // We now have an enum type.
        Console.WriteLine(importance == Importance.Medium);
    }
    }
}

Référence: http://www.dotnetperls.com/enum-parse

J'ai une implémentation optimisée que vous pouvez utiliser dans UnconstrainedMelody . En fait, il ne s'agit que de mettre en cache la liste des noms, mais cela se fait d'une manière agréable, fortement typée et contrainte de manière générique :)

enum EnumStatus
{
    NAO_INFORMADO = 0,
    ENCONTRADO = 1,
    BLOQUEADA_PELO_ENTREGADOR = 2,
    DISPOSITIVO_DESABILITADO = 3,
    ERRO_INTERNO = 4,
    AGARDANDO = 5
}

...

if (Enum.TryParse<EnumStatus>(item.status, out status)) {

}

Il n'y a actuellement aucun Enum.TryParse prêt à l'emploi. Cela a été demandé sur Connect ( toujours pas Enum.TryParse ) et a obtenu une réponse indiquant une éventuelle inclusion dans le prochain framework après .NET 3.5. Vous devrez mettre en œuvre les solutions de contournement suggérées pour le moment.

Le seul moyen d'éviter la gestion des exceptions est d'utiliser la méthode GetNames (), et nous savons tous que les exceptions ne doivent pas être utilisées abusivement pour la logique d'application commune :)

La mise en cache d'une fonction / dictionnaire généré dynamiquement est-elle autorisée?

Comme vous ne connaissez pas (semblez-vous) le type d'énumération à l'avance, la première exécution pourrait générer quelque chose dont les exécutions ultérieures pourraient tirer parti.

Vous pouvez même mettre en cache le résultat de Enum.GetNames ()

Essayez-vous d'optimiser le processeur ou la mémoire? En avez-vous vraiment besoin?

Comme d'autres l'ont déjà dit, si vous n'utilisez pas Try & Catch, vous devez utiliser IsDefined ou GetNames ... Voici quelques exemples ... ils sont fondamentalement tous les mêmes, le premier gérant des énumérations nullables. Je préfère le 2ème car c'est une extension sur des cordes, pas des enums ... mais vous pouvez les mélanger comme vous le souhaitez!

• www.objectreference.net/post/Enum-TryParse-Extension-Method.aspx
• flatlinerdoa.spaces.live.com/blog/cns!17124D03A9A052B0!605.entry
• mironabramson.com/blog/post/2008/03/Another-version-for-the-missing-method-EnumTryParse.aspx
• lazyloading.blogspot.com/2008/04/enumtryparse-with-net-35-extension.html

Il n'y a pas de TryParse car le type d'Enum n'est pas connu avant l'exécution. Un TryParse qui suit la même méthodologie que la méthode Date.TryParse lèverait une erreur de conversion implicite sur le paramètre ByRef.

Je suggère de faire quelque chose comme ça:

//1 line call to get value
MyEnums enumValue = (Sections)EnumValue(typeof(Sections), myEnumTextValue, MyEnums.SomeEnumDefault);

//Put this somewhere where you can reuse
public static object EnumValue(System.Type enumType, string value, object NotDefinedReplacement)
{
    if (Enum.IsDefined(enumType, value)) {
        return Enum.Parse(enumType, value);
    } else {
        return Enum.Parse(enumType, NotDefinedReplacement);
    }
}

Jetez un œil à la classe Enum (struct?) Elle-même. Il existe une méthode Parse à ce sujet, mais je ne suis pas sûr d'un tryparse.

Cette méthode convertira un type d'énumération:

  public static TEnum ToEnum<TEnum>(object EnumValue, TEnum defaultValue)
    {
        if (!Enum.IsDefined(typeof(TEnum), EnumValue))
        {
            Type enumType = Enum.GetUnderlyingType(typeof(TEnum));
            if ( EnumValue.GetType() == enumType )
            {
                string name = Enum.GetName(typeof(HLink.ViewModels.ClaimHeaderViewModel.ClaimStatus), EnumValue);
                if( name != null)
                    return (TEnum)Enum.Parse(typeof(TEnum), name);
                return defaultValue;
            }
        }
        return (TEnum)Enum.Parse(typeof(TEnum), EnumValue.ToString());
    } 

Il vérifie le type sous-jacent et obtient le nom par rapport à lui à analyser. Si tout échoue, la valeur par défaut sera renvoyée.