Wie wird ein Enum-Wert aus einer Zeichenfolge zurückgegeben?

Question

Ich versuche, einen stark typisierten Enumeration-Wert aus einer Zeichenfolge zurückzugeben. Ich bin mir sicher, dass es einen besseren Weg dafür gibt. Dies scheint einfach zu viel Code für eine einfache Sache wie folgt:

public static DeviceType DefaultDeviceType 
    { 
     get 
     { 
      var deviceTypeString = GetSetting("DefaultDeviceType"); 
      if (deviceTypeString.Equals(DeviceType.IPhone.ToString())) 
       return DeviceType.IPhone; 
      if (deviceTypeString.Equals(DeviceType.Android.ToString())) 
       return DeviceType.Android; 
      if (deviceTypeString.Equals(DeviceType.BlackBerry.ToString())) 
       return DeviceType.BlackBerry; 
      if (deviceTypeString.Equals(DeviceType.Other.ToString())) 
       return DeviceType.Other; 
      return DeviceType.IPhone; // If no default is provided, use this default. 
     } 
    } 

Ideen?

Basierend auf der Rückmeldung, die ich von der Community erhielt, habe ich mich entschieden, eine Methodenerweiterung zu verwenden, die eine Zeichenfolge in eine Aufzählung konvertiert. Es benötigt einen Parameter (den Standard-Enumerationswert). Dieser Standard stellt auch den Typ bereit, sodass das generische abgeleitet werden kann und nicht explizit mit <> angegeben werden muss. Die Methode ist jetzt auf diese verkürzt:

Sehr coole Lösung, die in der Zukunft wiederverwendet werden kann.

Answer 1

Wenn Sie mit (unzuverlässigen) Benutzereingaben arbeiten, verwende ich gerne eine Erweiterungsmethode, die einen Standardwert zulässt. Versuch es.

public static TResult ParseEnum<TResult>(this string value, TResult defaultValue) 
    { 
     try 
     { 
      return (TResult)Enum.Parse(typeof(TResult), value, true); 
     } 
     catch (ArgumentException) 
     { 
      return defaultValue; 
     } 
    } 

Answer 2

Verwendung Enum.Parse():

var deviceTypeString = GetSetting("DefaultDeviceType"); 
return (DeviceType)Enum.Parse(typeof(DeviceType), deviceTypeString); 

Wenn die Eingabe unzuverlässig ist, sollten Sie darauf achten, weil Sie eine ArgumentException erhalten, wenn der Wert nicht als einer der Werte der Enumeration interpretiert werden kann.

Es gibt auch eine Überlastung von Parse(), die es ermöglicht, Groß- und Kleinschreibung bei dieser Konvertierung zu ignorieren, falls erforderlich.

Answer 3

Ich schrieb diese Erweiterung Methode einmal in jedem beliebigen Aufzählungstyp von Zeichenfolge, auf diese Weise Sie den Conversion-Code immer und immer wieder zu schreiben, haben nicht zu konvertieren:

public static class StringExtensions 
    { 

    public static T ConvertToEnum<T>(this string value) 
    { 
     //Guard condition to not allow this to be used with any other type than an Enum 
     if (typeof(T).BaseType != typeof(Enum)) 
     { 
      throw new InvalidCastException(string.Format("ConvertToEnum does not support converting to type of [{0}]", typeof(T))); 
     } 


     if (Enum.IsDefined(typeof(T), value) == false) 
     { 
      //you can throw an exception if the string does not exist in the enum 
      throw new InvalidCastException(); 

      //If you prefer to return the first available enum as the default value then do this 
      Enum.GetNames(typeof (T))[0].ConvertToEnum<T>(); //Note: I haven't tested this 
     } 
     return (T)Enum.Parse(typeof(T), value); 
    } 
} 

nutzen zu können, tatsächlich es können Sie dies tun:

//This is a enumeration for testing 
enum MyEnumType 
{ 
    ENUM1, 
    ENUM2 
} 

//How to cast 
var myEnum = "ENUM2".ConvertToEnum<MyEnumType>(); 

MyEnum sollte an dieser Stelle gleich ENUM2