Enum.Parse(), конечно, более аккуратный способ?

Скажем, у меня есть перечисление,

public enum Colours
{
    Red,
    Blue
}

Единственный способ, которым я могу разбираться в них, - это что-то вроде:

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

Это вызовет System.ArgumentException, потому что "Зеленый" не является членом перечисления Colours.

Теперь я действительно ненавижу код обертки в try/catch, нет ли способа сделать это, что не включает в себя выполнение итерации через каждое перечисление Colours и сравнение строк с colour?

Ответы

Ответ 1

Сначала используйте Enum.IsDefined(), чтобы сохранить себя от обертывания в try/catch. Он вернет логическое значение того, является ли вход допустимым членом этого перечисления.

Ответ 2

Я считаю, что 4.0 имеет Enum.TryParse

В противном случае используйте метод расширения:

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

Ответ 3

Нет, для этого нет метода "no-throw" (a la TryParse, который есть у некоторых других классов).

Однако вы можете легко написать свой собственный, чтобы инкапсулировать логику try-catch (или проверку IsDefined) в один вспомогательный метод, чтобы он не загрязнял ваш код приложения:

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

Ответ 4

Если я разбираю "доверенное" перечисление, я использую Enum.Parse().
Под "доверенным" я имею в виду, я знаю, что он ВСЕГДА будет действительным перечислением без каких-либо ошибок... когда-либо!

Но бывают случаи, когда "вы никогда не знаете, что вы получите", и в те времена вам нужно использовать возвращаемое значение с нулевым значением. Так как .net не предлагает этого запеченного, вы можете сворачивать свои собственные. Вот мой рецепт:

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

Чтобы использовать этот метод, вызовите его так:

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

Просто добавьте этот метод в класс, который вы используете для хранения ваших других обычно используемых функций утилиты.

Ответ 5

Просто чтобы перейти по ссылке "Небеса" к .Net 4 Enum.TryParse < > , viz

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

Это можно использовать следующим образом:

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