¿Por qué las enums de unboxing producen resultados extraños?

Question

considerar los siguientes ::

Object box = 5; 
int @int = (int)box; // int = 5 
int? nullableInt = box as int?; // nullableInt = 5; 
StringComparison @enum = (StringComparison)box; // enum = OrdinalIgnoreCase 
StringComparison? nullableEnum = box as StringComparison?; // nullableEnum = null. 

2 cosas ::

1. ¿Por qué puedo unbox a StringComparison? Supongo que esto se debe a que su tipo subyacente es Int32, pero aún así me parece extraño.
2. ¿Por qué nullableEnum tiene un valor de nulo?

Como tengo entendido, el único unboxing válido es de un tipo de valor encuadrado en su tipo o en un tipo anulable. Si int puede desempaquetar a Enum, entonces ¿por qué no ocurre lo mismo con los valores que aceptan nulos? Del mismo modo, si en vez de 5 encasillé StringComparison.OrdinalIgnoreCase, sería nullableInt nulo, pero nullableEnum no lo sería.

Answer 1

Estrictamente hablando, yo creo que es un error endetalle de implementación de el tiempo de ejecución, ya que la especificación C# dice

Unboxing a un tipo anulable produce el valor nulo de la nullable- escriba si el operando fuente es nulo, o el resultado envuelto de unboxing la instancia del objeto al tipo subyacente del tipo anulable en caso contrario.

Es decir, si unboxing a StringComparison funciona, entonces unboxing a nullable <StringComparison> debería funcionar también. No está claro si ambos deberían funcionar o si ambos deberían fallar. La especificación dice que

Para una conversión unboxing a un tipo no anulable-valor dado para tener éxito en tiempo de ejecución, el valor del operando fuente debe ser una referencia a un valor en caja de la que no anulable -tipo de valor.

Debe decidir si un int encuadrado se considera un valor encasillado de tipo StringComparison porque el tipo subyacente de StringComparison es int. La especificación continúa diciendo que se genera una InvalidCastException si el cuadro contiene un "objeto incompatible".Un int es ciertamente "compatible" con StringComparison, ya que puede copiar de forma segura los cuatro bytes del montón en su variable StringComparison.

Answer 2

1) Sí, el tipo subyacente de enum es int y es por eso que funciona de esta manera. Aún más. Puede hacer lo siguiente:

enum MyEnum 
{ 
    One = 1, 
    Two = 2, 
} 

int i = 3; 
MyEnum myEnum = (MyEnum)i; // This works without exceptions. 

2) Debido a que es en realidad StringComparison?Nullable<StringComparison> que es de tipo diferente. Y el operador as solo comprueba si el objeto es del mismo tipo que el especificado en el operador.

Answer 3

Cuando lanza enum o entero para objetar, aún contiene información de tipo. Entonces box is StringComparison devolverá false. Pero está permitido lanzar cualquier enumeración o int a cualquier enumeración, por lo que funciona explícitamente el molde (StringComparison)box. Es un caso especial para enums. Nullable<T>, por otro lado, es solo una clase habitual, T no se maneja de ninguna manera específica cuando echas o revisas el tipo. Esta es la razón por la cual este código emitirá una excepción.

 StringComparison? nullableEnum = (StringComparison?)nullableInt;