Enum.Parse (), sûrement une manière plus ordonnée?

Question

Dire que j'ai un enum,

public enum Colours
{
    Red,
    Blue
}

La seule façon que je peux voir de l'analyse est de faire quelque chose comme:

string colour = "Green";
var col = (Colours)Enum.Parse(typeOf(Colours),colour);

Cela permettra de jeter un Système.ArgumentException parce que "Vert" n'est pas un membre de l' Colours enum.

Maintenant, j'ai vraiment hate d'emballage code de try/catch est, n'est-il pas plus propre façon de faire, ce qui n'implique pas de moi une itération à travers chaque Colours enum, et de faire une comparaison de chaîne à l'encontre colour?

Answer 1

Utilisez d’abord Enum.IsDefined() pour éviter de vous envelopper dans un essai / une capture. Il retournera une valeur booléenne indiquant si l'entrée est un membre valide de cette énumération.

Answer 2

Je crois que 4.0 a Enum.TryParse

Sinon, utilisez une méthode d'extension :

 public static bool TryParse<T>(this Enum theEnum, string valueToParse, out T returnValue)
{
    returnValue = default(T);
    int intEnumValue;
    if (Int32.TryParse(valueToParse, out intEnumValue))
    {
        if (Enum.IsDefined(typeof(T), intEnumValue))
        {
            returnValue = (T)(object)intEnumValue;
            return true;
        }
    }
    return false;
}
 

Answer 3

Juste pour développer le lien de Sky vers le .Net 4 Enum.TryParse <> , à savoir

 Enum.TryParse<TEnum>(
    string value,
    [bool ignoreCase,]
    out TEnum result
)
 

Ceci peut être utilisé comme suit:

     enum Colour
    {
        Red,
        Blue
    }

    private void ParseColours()
    {
        Colour aColour;

        // IMO using the actual enum type is intuitive, but Resharper gives 
        // "Access to a static member of a type via a derived type"
        if (Colour.TryParse("RED", true, out aColour))
        {
           // ... success
        }

        // OR, the compiler can infer the type from the out
        if (Enum.TryParse("Red", out aColour))
        {
           // ... success
        }

        // OR explicit type specification
        // (Resharper: Type argument specification is redundant)
        if (Enum.TryParse<Colour>("Red", out aColour))
        {
          // ... success
        }
    }
 

Answer 4

Non, il n'y a pas de méthode "no-throw" pour cela (à la TryParse que certaines autres classes ont).

Cependant, vous pouvez facilement écrire le vôtre afin d'encapsuler la logique try-catch (ou la vérification IsDefined) dans une méthode d'assistance afin qu'elle ne pollue pas le code de votre application:

 public static object TryParse(Type enumType, string value, out bool success)
{
  success = Enum.IsDefined(enumType, value);
  if (success)
  {
    return Enum.Parse(enumType, value);
  }
  return null;
}
 

Answer 5

Si je suis de l'analyse d'une "confiance" enum, puis-je utiliser Enum.Parse().
Par "confiance", je veux dire, je sais qu'il sera TOUJOURS valide enum sans jamais erroring... jamais!

Mais il ya des moments où "on ne sait jamais sur quoi on va tomber", et pour ces moments, vous devez utiliser un nullable valeur de retour. Depuis .net n'offre pas ce cuit, vous pouvez rouler votre propre. Voici ma recette:

public static TEnum? ParseEnum<TEnum>(string sEnumValue) where TEnum : struct
{
    TEnum eTemp;
    TEnum? eReturn = null;
    if (Enum.TryParse<TEnum>(sEnumValue, out eTemp) == true)
        eReturn = eTemp;
    return eReturn;
}

Pour utiliser cette méthode, l'appeler de la sorte:

eColor? SelectedColor = ParseEnum<eColor>("Red");

Il suffit d'ajouter cette méthode à une classe que vous utilisez pour stocker vos autres fonctions de l'utilitaire.