Cómo probar el valor de Enum para Enum?

Question

Quiero escribir una función que pueda validar un valor dado (pasado como una cadena) contra valores posibles de enum. En el caso de una coincidencia, debe devolver la instancia enum; de lo contrario, debería devolver un valor predeterminado.

La función no puede usar internamente try/catch, que excluye el uso de Enum.Parse, que arroja una excepción cuando se le da un argumento no válido.

me gustaría usar algo en la línea de una función TryParse para implementar esta:

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue) 
{ 
    object enumValue; 
    if (!TryParse (typeof (TEnum), strEnumValue, out enumValue)) 
    { 
     return defaultValue; 
    } 
    return (TEnum) enumValue; 
} 

Answer 1

Como han dicho otros, debe implementar su propio TryParse. Simon Mourier proporciona una implementación completa que se ocupa de todo.

Si está utilizando enums de bitfield (es decir, flags), también debe manejar una cadena como "MyEnum.Val1|MyEnum.Val2" que es una combinación de dos valores enum. Si solo llama al Enum.IsDefined con esta cadena, devolverá falso, aunque Enum.Parse lo maneje correctamente.

actualización

Como se ha mencionado por Lisa y Christian en los comentarios, Enum.TryParse ya está disponible para C# en .NET4 y hacia arriba.

MSDN Docs

Answer 2

Tener un vistazo a la clase Enum (struct?) Sí. Hay un método Parse sobre eso, pero no estoy seguro acerca de un tryparse.

Answer 3

La única manera de evitar el manejo de excepciones es utilizar el método de GetNames(), y todos sabemos que las excepciones no deben ser objeto de abuso para la lógica de aplicación común :)

Answer 4

No tenemos fuera de la caja de enumeración. TryParse. Esto se solicitó en Connect (Still no Enum.TryParse) y obtuvo una respuesta que indicaba la posible inclusión en el siguiente marco después de .NET 3.5. Tendrá que implementar las soluciones sugeridas por ahora.

Answer 5

¿Está permitido el almacenamiento en caché de una función/diccionario generado dinámicamente?

Porque no conoce (parece conocer) el tipo de enumeración antes de tiempo, la primera ejecución podría generar algo que las ejecuciones subsiguientes podrían aprovechar.

Incluso se puede almacenar en caché el resultado de Enum.GetNames()

¿Estás tratando de optimizar para la CPU o la memoria? ¿Tiene Realmente necesita?

Answer 6

Al final, usted tiene que poner en práctica este alrededor Enum.GetNames:

public bool TryParseEnum<T>(string str, bool caseSensitive, out T value) where T : struct { 
    // Can't make this a type constraint... 
    if (!typeof(T).IsEnum) { 
     throw new ArgumentException("Type parameter must be an enum"); 
    } 
    var names = Enum.GetNames(typeof(T)); 
    value = (Enum.GetValues(typeof(T)) as T[])[0]; // For want of a better default 
    foreach (var name in names) { 
     if (String.Equals(name, str, caseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase)) { 
      value = (T)Enum.Parse(typeof(T), name); 
      return true; 
     } 
    } 
    return false; 
} 

Notas adicionales:

• Enum.TryParse se incluye en .NET 4. Consulte aquí http://msdn.microsoft.com/library/dd991876(VS.100).aspx
• Otro enfoque sería Envuelva directamente Enum.Parse capturando la excepción lanzada cuando falla. Esto podría ser más rápido cuando se encuentra una coincidencia, pero es probable que sea más lento si no lo es. Dependiendo de los datos que está procesando, esto puede o no ser una mejora neta.

---

EDIT: Sólo se ve una mejor aplicación de la presente, que se almacena en caché la información necesaria: http://damieng.com/blog/2010/10/17/enums-better-syntax-improved-performance-and-tryparse-in-net-3-5

Answer 7

Enum.IsDefined va a hacer las cosas. Puede que no sea tan eficiente como podría ser un TryParse, pero funcionará sin ningún tipo de manejo.

public static TEnum ToEnum<TEnum>(this string strEnumValue, TEnum defaultValue) 
{ 
    if (!Enum.IsDefined(typeof(TEnum), strEnumValue)) 
     return defaultValue; 

    return (TEnum)Enum.Parse(typeof(TEnum), strEnumValue); 
} 

A tener en cuenta: un método TryParse se añadió en .NET 4.0.

Answer 8

Como otros ya se ha dicho, si no se utiliza Trate & captura, es necesario utilizar IsDefined o GetNames ... He aquí algunos ejemplos ... que básicamente son todos iguales, la primera uno manejando enumeraciones que aceptan nulos. Prefiero el segundo porque es una extensión de cadenas, no enumeraciones ... ¡pero puedes mezclarlas como quieras!

• www.objectreference.net/post/Enum-TryParse-Extension-Method.aspx
• flatlinerdoa.spaces.live.com/blog/cns!17124D03A9A052B0!605.entry
• mironabramson.com/ blog/poste/2008/03/Otro-versión-de-la-falta-método-EnumTryParse.aspx
• lazyloading.blogspot.com/2008/04/enumtryparse-with-net-35-extension.html

Answer 9

Tengo una implementación optimizada que puede usar en UnconstrainedMelody. Efectivamente es sólo el almacenamiento en caché la lista de nombres, pero es hacerlo en un buen establecimiento inflexible manera, genéricamente constreñido :)

Answer 10

Este método será convertir un tipo de enumeración:

public static TEnum ToEnum<TEnum>(object EnumValue, TEnum defaultValue) 
    { 
     if (!Enum.IsDefined(typeof(TEnum), EnumValue)) 
     { 
      Type enumType = Enum.GetUnderlyingType(typeof(TEnum)); 
      if (EnumValue.GetType() == enumType) 
      { 
       string name = Enum.GetName(typeof(HLink.ViewModels.ClaimHeaderViewModel.ClaimStatus), EnumValue); 
       if(name != null) 
        return (TEnum)Enum.Parse(typeof(TEnum), name); 
       return defaultValue; 
      } 
     } 
     return (TEnum)Enum.Parse(typeof(TEnum), EnumValue.ToString()); 
    } 

Se comprueba el tipo subyacente y obtener el nombre en contra de él para analizar. Si todo falla, devolverá el valor predeterminado.

Answer 11

No hay un TryParse porque el tipo de Enum no se conoce hasta el tiempo de ejecución. Un TryParse que sigue la misma metodología que el método Date.TryParse arrojaría un error de conversión implícita en el parámetro ByRef.

Sugiero hacer algo como esto:

//1 line call to get value 
MyEnums enumValue = (Sections)EnumValue(typeof(Sections), myEnumTextValue, MyEnums.SomeEnumDefault); 

//Put this somewhere where you can reuse 
public static object EnumValue(System.Type enumType, string value, object NotDefinedReplacement) 
{ 
    if (Enum.IsDefined(enumType, value)) { 
     return Enum.Parse(enumType, value); 
    } else { 
     return Enum.Parse(enumType, NotDefinedReplacement); 
    } 
} 

Answer 12

Aquí es una implementación personalizada de EnumTryParse. A diferencia de otras implementaciones comunes, también admite la enumeración con el atributo Flags.

/// <summary> 
    /// Converts the string representation of an enum to its Enum equivalent value. A return value indicates whether the operation succeeded. 
    /// This method does not rely on Enum.Parse and therefore will never raise any first or second chance exception. 
    /// </summary> 
    /// <param name="type">The enum target type. May not be null.</param> 
    /// <param name="input">The input text. May be null.</param> 
    /// <param name="value">When this method returns, contains Enum equivalent value to the enum contained in input, if the conversion succeeded.</param> 
    /// <returns> 
    /// true if s was converted successfully; otherwise, false. 
    /// </returns> 
    public static bool EnumTryParse(Type type, string input, out object value) 
    { 
     if (type == null) 
      throw new ArgumentNullException("type"); 

     if (!type.IsEnum) 
      throw new ArgumentException(null, "type"); 

     if (input == null) 
     { 
      value = Activator.CreateInstance(type); 
      return false; 
     } 

     input = input.Trim(); 
     if (input.Length == 0) 
     { 
      value = Activator.CreateInstance(type); 
      return false; 
     } 

     string[] names = Enum.GetNames(type); 
     if (names.Length == 0) 
     { 
      value = Activator.CreateInstance(type); 
      return false; 
     } 

     Type underlyingType = Enum.GetUnderlyingType(type); 
     Array values = Enum.GetValues(type); 
     // some enums like System.CodeDom.MemberAttributes *are* flags but are not declared with Flags... 
     if ((!type.IsDefined(typeof(FlagsAttribute), true)) && (input.IndexOfAny(_enumSeperators) < 0)) 
      return EnumToObject(type, underlyingType, names, values, input, out value); 

     // multi value enum 
     string[] tokens = input.Split(_enumSeperators, StringSplitOptions.RemoveEmptyEntries); 
     if (tokens.Length == 0) 
     { 
      value = Activator.CreateInstance(type); 
      return false; 
     } 

     ulong ul = 0; 
     foreach (string tok in tokens) 
     { 
      string token = tok.Trim(); // NOTE: we don't consider empty tokens as errors 
      if (token.Length == 0) 
       continue; 

      object tokenValue; 
      if (!EnumToObject(type, underlyingType, names, values, token, out tokenValue)) 
      { 
       value = Activator.CreateInstance(type); 
       return false; 
      } 

      ulong tokenUl; 
      switch (Convert.GetTypeCode(tokenValue)) 
      { 
       case TypeCode.Int16: 
       case TypeCode.Int32: 
       case TypeCode.Int64: 
       case TypeCode.SByte: 
        tokenUl = (ulong)Convert.ToInt64(tokenValue, CultureInfo.InvariantCulture); 
        break; 

       //case TypeCode.Byte: 
       //case TypeCode.UInt16: 
       //case TypeCode.UInt32: 
       //case TypeCode.UInt64: 
       default: 
        tokenUl = Convert.ToUInt64(tokenValue, CultureInfo.InvariantCulture); 
        break; 
      } 

      ul |= tokenUl; 
     } 
     value = Enum.ToObject(type, ul); 
     return true; 
    } 

    private static char[] _enumSeperators = new char[] { ',', ';', '+', '|', ' ' }; 

    private static object EnumToObject(Type underlyingType, string input) 
    { 
     if (underlyingType == typeof(int)) 
     { 
      int s; 
      if (int.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(uint)) 
     { 
      uint s; 
      if (uint.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(ulong)) 
     { 
      ulong s; 
      if (ulong.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(long)) 
     { 
      long s; 
      if (long.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(short)) 
     { 
      short s; 
      if (short.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(ushort)) 
     { 
      ushort s; 
      if (ushort.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(byte)) 
     { 
      byte s; 
      if (byte.TryParse(input, out s)) 
       return s; 
     } 

     if (underlyingType == typeof(sbyte)) 
     { 
      sbyte s; 
      if (sbyte.TryParse(input, out s)) 
       return s; 
     } 

     return null; 
    } 

    private static bool EnumToObject(Type type, Type underlyingType, string[] names, Array values, string input, out object value) 
    { 
     for (int i = 0; i < names.Length; i++) 
     { 
      if (string.Compare(names[i], input, StringComparison.OrdinalIgnoreCase) == 0) 
      { 
       value = values.GetValue(i); 
       return true; 
      } 
     } 

     if ((char.IsDigit(input[0]) || (input[0] == '-')) || (input[0] == '+')) 
     { 
      object obj = EnumToObject(underlyingType, input); 
      if (obj == null) 
      { 
       value = Activator.CreateInstance(type); 
       return false; 
      } 
      value = obj; 
      return true; 
     } 

     value = Activator.CreateInstance(type); 
     return false; 
    } 

Answer 13

Basado en .NET 4.5

código de ejemplo siguiente

using System; 

enum Importance 
{ 
    None, 
    Low, 
    Medium, 
    Critical 
} 

class Program 
{ 
    static void Main() 
    { 
    // The input value. 
    string value = "Medium"; 

    // An unitialized variable. 
    Importance importance; 

    // Call Enum.TryParse method. 
    if (Enum.TryParse(value, out importance)) 
    { 
     // We now have an enum type. 
     Console.WriteLine(importance == Importance.Medium); 
    } 
    } 
} 

Referencia: http://www.dotnetperls.com/enum-parse

Answer 14

enum EnumStatus 
    { 

     NAO_INFORMADO = 0, 
     ENCONTRADO = 1, 
     BLOQUEADA_PELO_ENTREGADOR = 2, 
     DISPOSITIVO_DESABILITADO = 3, 
     ERRO_INTERNO = 4, 
     AGARDANDO = 5 

    } 

...

if (Enum.TryParse<EnumStatus>(item.status, out status)) { 

}