Comment renvoyer une valeur Enum à partir d'une chaîne?

Question

J'essaie de renvoyer une valeur d'énumération fortement typée à partir d'une chaîne. Je suis sûr qu'il y a une meilleure façon de le faire. Cela semble juste beaucoup trop de code pour une chose simple comme ceci:

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. 
     } 
    } 

Idées? Sur la base des commentaires que j'ai reçus de la communauté, j'ai décidé d'utiliser une extension de méthode qui convertit une chaîne en une énumération. Il prend un paramètre (la valeur d'énumération par défaut). Cette valeur par défaut fournit également le type, de sorte que le générique peut être déduit et n'a pas besoin d'être spécifié explicitement en utilisant <>. La méthode est maintenant raccourcie à ceci:

public static DeviceType DefaultDeviceType 
    { 
     get 
     { 
      return GetSetting("DefaultDeviceType").ToEnum(DeviceType.IPhone); 
     } 
    } 

Solution très cool qui peut être réutilisée dans le futur.

Answer 1

Si vous traitez avec une entrée d'utilisateur (non fiable), j'aime utiliser une méthode d'extension qui permet une valeur par défaut. Essaye le.

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

Utilisation Enum.Parse():

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

Si l'entrée est peu fiable, vous devez prendre soin, parce que vous obtiendrez un ArgumentException si la valeur ne peut être interprétée comme l'une des valeurs de l'ENUM.

Il existe également une surcharge de Parse() qui vous permet d'ignorer le cas lors de cette conversion, si nécessaire.

Answer 3

j'ai écrit cette méthode d'extension une fois pour convertir à tout tout type enum de chaîne, de cette façon vous n'avez pas à écrire le code de conversion encore et encore:

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

Pour utiliser réellement il vous pouvez le faire:

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

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

MyEnum à ce point doit être égal ENUM2