¿Por qué Enum.Parse crea entradas indefinidas?

Question

class Program 
{ 
    static void Main(string[] args) 
    { 
     string value = "12345"; 
     Type enumType = typeof(Fruits); 
     Fruits fruit = Fruits.Apple; 
     try 
     { 
      fruit = (Fruits) Enum.Parse(enumType, value); 
     } 
     catch (ArgumentException) 
     { 
      Console.WriteLine(String.Format("{0} is no healthy food.", value)); 
     } 
     Console.WriteLine(String.Format("You should eat at least one {0} per day.", fruit)); 
     Console.ReadKey(); 
    } 

    public enum Fruits 
    { 
     Apple, 
     Banana, 
     Orange 
    } 
} 

Si se ejecuta el código anterior muestra el resultado:

Usted debe comer por lo menos un 12,345 por día.

Realmente esperaba que se lanzara una ArgumentException si se pasa un nombre desconocido (cadena). Tomando una mirada cercana a la definición Enum.Parse revela:

Resumen:
Convierte la representación de cadena del nombre o valor numérico de una o más constantes enumeradas a un objeto equivalente enumerado.

Excepciones:
ArgumentException: enumType no es una enumeración. -o-- value es una cadena vacía o solo contiene espacios en blanco. -o-- valor es un nombre, pero no una de las constantes con nombre definidas para la enumeración.

I.e. si se pasa una representación de cadena de un entero, se crea un nuevo valor enum y ahora se lanza una excepción por diseño. ¿Esto tiene sentido?

Al menos ahora sé que llamar Enum.IsDefined(enumType, value) antes Enum.Parse()

Answer 1

La "constante con nombre" es la representación textual del valor de Enum, no el número que le ha asignado.

Si cambia:

string value = "12345"; 

Para:

string value = "Cake"; 

Vas a ver el error que usted está esperando, porque "el valor es un nombre, pero no una de las constantes con nombre definido para la enumeración ". En este caso, el valor que está pasando en es, un nombre, "Pastel", pero no uno en la enumeración.

Piense en Enum.Parse(enumType, value); haciendo lo siguiente:

1. Si value es una referencia nula, lanzar una ArgumentNullException
2. Es el valor en value una de las constantes con nombre de la enumeración en enumType. En caso afirmativo, devuelva ese valor de la enumeración y deténgalo.
3. Es el valor en value directamente convertible al tipo subyacente (en este caso Int32), si es así, devuelva ese valor y pare (incluso si no hay una constante con nombre para ese valor).
4. ¿Es el valor en value directamente convertible al tipo subyacente, pero fuera del rango del tipo subyacente? p.ej. el valor es una cadena que contiene un número uno mayor que MAXINT. Si es así, arroja un OverflowException.
5. ¿El valor no es moldeable para el tipo subyacente? Si es así, lanza una ArgumentException.

Answer 2

Es necesario utilizar Enum.IsDefined:

http://msdn.microsoft.com/en-us/library/essfb559.aspx

using System; 

    [Flags] enum Colors { None=0, Red = 1, Green = 2, Blue = 4 }; 

    public class Example 
    { 
     public static void Main() 
     { 
      string[] colorStrings = { "0", "2", "8", "blue", "Blue", "Yellow", "Red, Green" }; 
      foreach (string colorString in colorStrings) 
      { 
      try { 
       Colors colorValue = (Colors) Enum.Parse(typeof(Colors), colorString);   
       if (Enum.IsDefined(typeof(Colors), colorValue) | colorValue.ToString().Contains(",")) 
        Console.WriteLine("Converted '{0}' to {1}.", colorString, colorValue.ToString()); 
       else 
        Console.WriteLine("{0} is not an underlying value of the Colors enumeration.", colorString); 
      } 
      catch (ArgumentException) { 
       Console.WriteLine("'{0}' is not a member of the Colors enumeration.", colorString); 
      } 
      } 
     } 
    } 
    // The example displays the following output: 
    //  Converted '0' to None. 
    //  Converted '2' to Green. 
    //  8 is not an underlying value of the Colors enumeration. 
    //  'blue' is not a member of the Colors enumeration. 
    //  Converted 'Blue' to Blue. 
    //  'Yellow' is not a member of the Colors enumeration. 
    //  Converted 'Red, Green' to Red, Green. 

Answer 3

yo personalmente creo que es una lástima que Enum.Parse acepta la cuerda representación de un número. Si está buscando una alternativa, puede consultar mi proyecto Unconstrained Melody, que tiene varias opciones de análisis, y también está fuertemente tipado.

Ciertamente puede use Enum.IsDefined junto con el análisis. ¿Definitivamente usted quiere para aceptar versiones de cadena de números? ¿O realmente solo estás esperando nombres?

Answer 4

Un enum puede ser cualquier valor de su tipo de entero base. No está solo restringido a constantes con nombre.

Por ejemplo, el siguiente es perfectamente válido:

enum Foo{ 
    A, 
    B, 
    C, 
    D 
} 

Foo x = (Foo)5; 

5 A pesar de que no corresponde a una constante con nombre, todavía es un valor válido para Foo, ya que el tipo subyacente de Foo es Int32.

Si se llamara x.ToString(), el valor devuelto sería simplemente "5", ya que ninguna constante con nombre corresponde con el valor de x.

Enum.Parse() es la función inversa de Enum.ToString(). Debería esperar que cualquiera que sea Enum.ToString() puede devolver que Enum.Parse() puede aceptar. Esto incluye, por ejemplo, valores separados por comas de banderas enumeraciones:

[Flags] 
enum Foo{ 
    A = 1, 
    B = 2, 
    C = 4, 
    D = 8 
} 

Foo x = Foo.A | Foo.B | Foo.C | Foo.D; 
int i = (int)x; 
string s = x.ToString(); 
Console.WriteLine(i); 
Console.WriteLine(s); 
Console.WriteLine((Foo)Enum.Parse(typeof(Foo), i.ToString()) == x); 
Console.WriteLine((Foo)Enum.Parse(typeof(Foo), s) == x); 

Salida:

 
15 
A, B, C, D 
True 
True 

EDIT:

Lo que realmente parece querer decir algo como esto:

static Enum GetEnumValue(Type enumType, string name){ 
    // null-checking omitted for brevity 

    int index = Array.IndexOf(Enum.GetNames(enumType), name); 
    if(index < 0) 
     throw new ArgumentException("\"" + name + "\" is not a value in " + enumType, "name"); 

    return Enum.GetValues(enumType).GetValue(index); 
} 

o una versión sin mayúsculas y minúsculas:

static Enum GetEnumValue(Type enumType, string name, bool ignoreCase){ 
    // null-checking omitted 

    int index; 
    if(ignoreCase) 
     index = Array.FindIndex(Enum.GetNames(enumType), 
      s => string.Compare(s, name, StringComparison.OrdinalIgnoreCase) == 0); 
      // or StringComparison.CurrentCultureIgnoreCase or something if you 
      // need to support fancy Unicode names 
    else index = Array.IndexOf(Enum.GetNames(enumType), name); 

    if(index < 0) 
     throw new ArgumentException("\"" + name + "\" is not a value in " + enumType, "name"); 

    return Enum.GetValues(enumType).GetValue(index); 
}