Parse String Aufzählungstyp

Question

Ich habe einen Aufzählungstyp wie dies als Beispiel:

public Enum MyEnum { 
    enum1, enum2, enum3 }; 

Ich werde eine Reihe von Konfigurationsdatei lesen. Was ich brauche, um die Zeichenfolge zu MyEnum-Typ oder Null zu analysieren o nicht definiert. Nicht sicher, ob die folgenden Codes funktionieren (sorry für nicht jetzt Zugriff auf meinen VS hat):

// example: ParseEnum<MyEnum>("ENUM1", ref eVal); 
bool ParseEnum<T>(string value1, ref eVal) where T : Enum 
{ 
    bool bRet = false; 
    var x = from x in Enum.GetNames(typeof(T)) where 
     string.Equals(value1, x, StringComparison. OrdinalIgnoreCase) 
     select x; 
    if (x.Count() == 1) 
    { 
    eVal = Enum.Parse(typeof(T), x.Item(0)) as T; 
    bRet = true; 
    } 
    return bRet; 
} 

nicht sicher, ob es richtig ist, oder gibt es andere einfache Möglichkeit, eine Zeichenfolge zu MyEnum Wert zu analysieren?

Answer 1

Was ist so etwas wie:

public static class EnumUtils 
{ 
    public static Nullable<T> Parse<T>(string input) where T : struct 
    { 
     //since we cant do a generic type constraint 
     if (!typeof(T).IsEnum) 
     { 
      throw new ArgumentException("Generic Type 'T' must be an Enum"); 
     } 
     if (!string.IsNullOrEmpty(input)) 
     { 
      if (Enum.GetNames(typeof(T)).Any(
        e => e.Trim().ToUpperInvariant() == input.Trim().ToUpperInvariant())) 
      { 
       return (T)Enum.Parse(typeof(T), input, true); 
      } 
     } 
     return null; 
    } 
} 

als:

MyEnum? value = EnumUtils.Parse<MyEnum>("foo"); 

(Hinweis: alte Version try/catch um Enum.Parse verwendet)

Answer 2

private enum MyEnum 
{ 
    Enum1 = 1, Enum2 = 2, Enum3 = 3, Enum4 = 4, Enum5 = 5, Enum6 = 6, 
    Enum7 = 7, Enum8 = 8, Enum9 = 9, Enum10 = 10 
} 

private static Object ParseEnum<T>(string s) 
{ 
    try 
    { 
     var o = Enum.Parse(typeof (T), s); 
     return (T)o; 
    } 
    catch(ArgumentException) 
    { 
     return null; 
    } 
} 

static void Main(string[] args) 
{ 
    Console.WriteLine(ParseEnum<MyEnum>("Enum11")); 
    Console.WriteLine(ParseEnum<MyEnum>("Enum1")); 
    Console.WriteLine(ParseEnum<MyEnum>("Enum6").GetType()); 
    Console.WriteLine(ParseEnum<MyEnum>("Enum10")); 
} 

OUTPUT:

Answer 3

Wenn Sie .NET 3.5 (oder sogar 2,0, wenn Sie die Erweiterung Methode trimmen), habe ich in diesem Artikel mit den Techniken großes Glück hatte:

Aufzählungen und Streicher - Stoppen Sie den Wahnsinn !

EDIT: Domain ist weg und ist jetzt eine Linkfarm. Ich zog den Code (leicht modifizierte und hinzugefügt, um im Laufe der Zeit) von unserer Code-Basis bei der Arbeit, die Sie jetzt hier finden:

https://gist.github.com/1305566

Answer 4

Ich habe eine TryParseName Methode in UnconstrainedMelody, eine Bibliothek für die Delegierten und Enum-Dienstprogramm Methoden, die "unaussprechliche" Constraints über einige Postbuild-Tricks verwenden. (Code- mit der Bibliothek keine postbuild brauchen, um nur klar zu sein.)

Sie würde es so verwenden:

Foo foo; 
bool parsed = Enums.TryParseName<Foo>(name, out foo); 

ich derzeit keine Groß- und Kleinschreibung Version haben, aber ich könnte es leicht einführen, wenn du wolltest. Beachten Sie, dass nicht versucht, Zahlen zu analysieren, z. "12" wie die integrierte Version, und versucht auch nicht, durch Kommas getrennte Listen von Flags zu analysieren. Ich kann die Flaggenversion später hinzufügen, aber ich kann nicht viel Punkt in der numerischen Version sehen.

Dies geschieht ohne Boxing und ohne Überprüfung der Ausführungszeit. die Einschränkung zu haben, ist wirklich praktisch :)

Bitte lassen Sie mich wissen, wenn Sie sinnvoll, ein Groß- und Kleinschreibung Parse finden würde ...

Answer 5

ich nur die Syntax von here, mit Ausnahme von here Handhabung kombiniert haben, diese zu erstellen:

public static class Enum<T> 
{ 
    public static T Parse(string value) 
    { 
     //Null check 
     if(value == null) throw new ArgumentNullException("value"); 
     //Empty string check 
     value = value.Trim(); 
     if(value.Length == 0) throw new ArgumentException("Must specify valid information for parsing in the string", "value"); 
     //Not enum check 
     Type t = typeof(T); 
     if(!t.IsEnum) throw new ArgumentException("Type provided must be an Enum", "TEnum"); 

     return (T)Enum.Parse(typeof(T), value); 
    } 
} 

Sie es ein bisschen drehen könnte null statt werfen Ausnahmen zurückzukehren.

Answer 6

Sie können TryParse verwenden, wenn Sie try/catch vermeiden möchten.

MyEnum eVal; 
if (Enum.TryParse("ENUM2", true, out eVal)){ 
    // now eVal is the enumeration element: enum2 
} 
//unable to parse. You can log the error, exit, redirect, etc... 

Ich modifizierte die ausgewählte Antwort ein wenig. Ich hoffe du magst es.

Answer 7

Dies ist eine alte Frage, aber jetzt hat .NET 4.5 Enum.TryParse().

http://msdn.microsoft.com/en-us/library/dd991317.aspx

Answer 8

Enum Rückkehr von string, wenn enthält:

public static T GetEnum<T>(string s) 
    { 
     Array arr = Enum.GetValues(typeof(T)); 
     foreach (var x in arr) 
     { 
      if (x.ToString().Contains(s)) 
       return (T)x; 
     } 
     return default(T); 
    }