Come TryParse per il valore Enum?

Voglio scrivere una funzione che possa convalidare un dato valore (passato come stringa) rispetto a possibili valori di un file enum. Nel caso di una corrispondenza, dovrebbe restituire l'istanza enum; in caso contrario, dovrebbe restituire un valore predefinito.

La funzione non può utilizzare internamente try/ catch, che esclude using Enum.Parse, che genera un'eccezione quando viene fornito un argomento non valido.

Mi piacerebbe usare qualcosa sulla falsariga di una TryParsefunzione per implementare questo:

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

Come altri hanno già detto, devi implementare il tuo TryParse. Simon Mourier fornisce un'implementazione completa che si prende cura di tutto.

Se stai usando enumerazioni bitfield (cioè flag), devi anche gestire una stringa come la "MyEnum.Val1|MyEnum.Val2"combinazione di due valori enum. Se chiami solo Enum.IsDefinedcon questa stringa, restituirà false, anche se la Enum.Parsegestisce correttamente.

Aggiornare

Come menzionato da Lisa e Christian nei commenti, Enum.TryParseè ora disponibile per C # in .NET4 e versioni successive.

Documenti MSDN

Enum.IsDefined farà le cose. Potrebbe non essere efficiente come probabilmente sarebbe un TryParse, ma funzionerà senza la gestione delle eccezioni.

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

Da segnalare: un TryParsemetodo è stato aggiunto in .NET 4.0.

Ecco un'implementazione personalizzata di EnumTryParse. A differenza di altre implementazioni comuni, supporta anche l'enumerazione contrassegnata con l' Flagsattributo.

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

Alla fine devi implementare questo intorno 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;
}

Note aggiuntive:

• Enum.TryParseè incluso in .NET 4. Vedere qui http://msdn.microsoft.com/library/dd991876(VS.100).aspx
• Un altro approccio sarebbe quello di eseguire il wrapping direttamente Enum.Parsecatturando l'eccezione generata quando fallisce. Potrebbe essere più veloce quando viene trovata una corrispondenza, ma in caso contrario sarà probabilmente più lento. A seconda dei dati che stai elaborando, questo può o meno essere un netto miglioramento.

EDIT: ho appena visto un'implementazione migliore su questo, che memorizza nella cache le informazioni necessarie: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5

Basato su .NET 4.5

Codice di esempio di seguito

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

Riferimento: http://www.dotnetperls.com/enum-parse

Ho un'implementazione ottimizzata che potresti usare in UnconstrainedMelody . Effettivamente sta solo memorizzando nella cache l'elenco dei nomi, ma lo sta facendo in un modo carino, fortemente tipizzato, genericamente vincolato :)

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)) {

}

Al momento non esiste un Enum.TryParse predefinito. Questo è stato richiesto su Connect ( Still no Enum.TryParse ) e ha ottenuto una risposta che indicava la possibile inclusione nel framework successivo dopo .NET 3.5. Per ora dovrai implementare le soluzioni alternative suggerite.

L'unico modo per evitare la gestione delle eccezioni è utilizzare il metodo GetNames () e sappiamo tutti che le eccezioni non dovrebbero essere abusate per la logica dell'applicazione comune :)

La memorizzazione nella cache di una funzione / dizionario generato dinamicamente è consentita?

Poiché non si (sembra) conoscere il tipo di enumerazione in anticipo, la prima esecuzione potrebbe generare qualcosa di cui le successive esecuzioni potrebbero trarre vantaggio.

Puoi persino memorizzare nella cache il risultato di Enum.GetNames ()

Stai cercando di ottimizzare per CPU o memoria? Ne hai davvero bisogno?

Come altri hanno già detto, se non usi Try & Catch, devi usare IsDefined o GetNames ... Ecco alcuni esempi ... fondamentalmente sono tutti uguali, il primo che gestisce enumerazioni nullable. Preferisco il secondo perché è un'estensione sulle corde, non sulle enumerazioni ... ma puoi mescolarle come vuoi!

• 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

Non esiste un TryParse perché il tipo di Enum non è noto fino al runtime. Un TryParse che segue la stessa metodologia del metodo Date.TryParse genererebbe un errore di conversione implicito sul parametro ByRef.

Suggerisco di fare qualcosa del genere:

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

Dai un'occhiata alla stessa classe Enum (struct?). Esiste un metodo Parse su questo ma non sono sicuro di un tryparse.

Questo metodo convertirà un tipo di enum:

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

Controlla il tipo sottostante e ottiene il nome per analizzarlo. Se tutto fallisce, restituirà il valore predefinito.