Wie TryParse für Enum-Wert?

Ich möchte eine Funktion schreiben, die einen bestimmten Wert (als Zeichenfolge übergeben) anhand möglicher Werte von a validieren kann enum. Im Falle einer Übereinstimmung sollte die Aufzählungsinstanz zurückgegeben werden. Andernfalls sollte ein Standardwert zurückgegeben werden.

Die Funktion verwendet try/ möglicherweise nicht intern catch, was die Verwendung ausschließt Enum.Parse, wodurch eine Ausnahme ausgelöst wird , wenn ein ungültiges Argument angegeben wird.

Ich möchte etwas in der Art einer TryParseFunktion verwenden, um dies zu implementieren:

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

Wie andere gesagt haben, müssen Sie Ihre eigenen implementieren TryParse. Simon Mourier bietet eine vollständige Implementierung, die sich um alles kümmert.

Wenn Sie Bitfeld-Aufzählungen (dh Flags) verwenden, müssen Sie auch eine Zeichenfolge behandeln, bei "MyEnum.Val1|MyEnum.Val2"der es sich um eine Kombination aus zwei Aufzählungswerten handelt. Wenn Sie nur Enum.IsDefinedmit dieser Zeichenfolge aufrufen , wird false zurückgegeben, obwohl Enum.Parsedies korrekt behandelt wird.

Aktualisieren

Wie von Lisa und Christian in den Kommentaren erwähnt, Enum.TryParseist es jetzt für C # in .NET4 und höher verfügbar.

MSDN Docs

Enum.IsDefined erledigt alles. Es ist möglicherweise nicht so effizient wie ein TryParse, funktioniert aber ohne Ausnahmebehandlung.

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

Bemerkenswert: TryParseIn .NET 4.0 wurde eine Methode hinzugefügt.

Hier ist eine benutzerdefinierte Implementierung von EnumTryParse. Im Gegensatz zu anderen gängigen Implementierungen unterstützt es auch die mit dem FlagsAttribut gekennzeichnete Aufzählung .

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

Am Ende müssen Sie dies umsetzen 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;
}

Zusätzliche Bemerkungen:

• Enum.TryParseist in .NET 4 enthalten. Siehe hier http://msdn.microsoft.com/library/dd991876(VS.100).aspx
• Ein anderer Ansatz wäre, Enum.Parsedie Ausnahme, die ausgelöst wird, wenn sie fehlschlägt , direkt zu verpacken . Dies kann schneller sein, wenn eine Übereinstimmung gefunden wird, wird aber wahrscheinlich langsamer, wenn nicht. Abhängig von den Daten, die Sie verarbeiten, kann dies eine Nettoverbesserung sein oder auch nicht.

EDIT: Habe gerade eine bessere Implementierung gesehen, die die notwendigen Informationen zwischenspeichert: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net- 3-5

Basierend auf .NET 4.5

Beispielcode unten

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

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

Ich habe eine optimierte Implementierung, die Sie in UnconstrainedMelody verwenden können . Tatsächlich wird nur die Liste der Namen zwischengespeichert, aber dies geschieht auf eine nette, stark typisierte, generisch eingeschränkte Art und Weise :)

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

}

Derzeit gibt es kein sofort einsatzbereites Enum.TryParse. Dies wurde bei Connect angefordert ( noch kein Enum.TryParse ) und erhielt eine Antwort, die auf eine mögliche Aufnahme in das nächste Framework nach .NET 3.5 hinweist. Sie müssen zunächst die vorgeschlagenen Problemumgehungen implementieren.

Die einzige Möglichkeit, die Ausnahmebehandlung zu vermeiden, ist die Verwendung der GetNames () -Methode. Wir alle wissen, dass Ausnahmen nicht für die allgemeine Anwendungslogik missbraucht werden sollten :)

Ist das Zwischenspeichern einer dynamisch generierten Funktion / eines Wörterbuchs zulässig?

Da Sie den Typ der Aufzählung nicht im Voraus zu kennen scheinen, könnte die erste Ausführung etwas erzeugen, das nachfolgende Ausführungen ausnutzen könnten.

Sie können sogar das Ergebnis von Enum.GetNames () zwischenspeichern

Versuchen Sie, für CPU oder Speicher zu optimieren? Müssen Sie wirklich ?

Wie andere bereits sagten, müssen Sie IsDefined oder GetNames verwenden, wenn Sie Try & Catch nicht verwenden ... Hier sind einige Beispiele ... sie sind im Grunde alle gleich, das erste, das nullfähige Aufzählungen behandelt. Ich bevorzuge die zweite, da es sich um eine Erweiterung für Strings handelt, nicht für Enums ... aber Sie können sie mischen, wie Sie möchten!

• 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

Es gibt kein TryParse, da der Typ der Aufzählung erst zur Laufzeit bekannt ist. Ein TryParse, der der gleichen Methode wie die Date.TryParse-Methode folgt, würde einen impliziten Konvertierungsfehler für den ByRef-Parameter auslösen.

Ich schlage vor, so etwas zu tun:

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

Schauen Sie sich die Enum-Klasse (struct?) Selbst an. Es gibt eine Parse-Methode, aber ich bin mir bei einer Tryparse nicht sicher.

Diese Methode konvertiert einen Aufzählungstyp:

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

Es überprüft den zugrunde liegenden Typ und erhält den Namen zum Parsen. Wenn alles fehlschlägt, wird der Standardwert zurückgegeben.