¿Cómo puede CLR omitir el error de lanzamiento al asignar un valor nulo a la estructura?

Question

estoy tratando de entender una cosa en este código:

Nullable<Int32> x = 5; 
Nullable<Int32> y = null; 
Console.WriteLine("x: HasValue={0}, Value={1}", x.HasValue, x.Value); 
Console.WriteLine("y: HasValue={0}, Value={1}", y.HasValue, y.GetValueOrDefault()); 

y la salida es:

x: HasValue=True, Value=5 
y: HasValue=False, Value=0 

Y lo que no entiendo cuando se pasa a nully, creo que llama a public static implicit operator Nullable<T>(T value) pero la definición de este método inicializa una nueva estructura que pasa value que está asignada null, pero el método constructor no verifica si es nula o no, por lo que puede asignar default(T) a .

¿Cómo es que incluso podemos asignar null a struct aquí y funciona bien?

¿Pueden chicos lo que me estoy perdiendo aquí? No entiendo cómo pasó por alto null y devolvió el valor predeterminado.

código anulable definición interna:

http://codepaste.net/gtce6d

Answer 1

creen que llama operador implícita public static anulable (T valor)

No no lo hace, porque T es Int32 en este caso, y null no es Int32. Solo deja la variable y predeterminada, lo que significa que para una estructura todos los bytes son 0. Esto da como resultado una estructura que tiene un HasValue que devuelve false.

No se puede pasar realmente null a una estructura, pero el compilador de C# está convirtiendo esto para su inicialización predeterminada.

Answer 2

El valor por defecto se le asigna en el constructor llamado por new Nullable<T>(value); (línea 40)

Answer 3

Supongo que al asignar null a un valor nulo se llama al constructor predeterminado. Esa es la única forma posible de que hasValue permanezca en false.

Answer 4

A Nullable<T> es simplemente una estructura que tiene un campo booleano que indica si tiene un valor, y un campo que (si el primer campo es verdadero) indica cuál es ese valor. No es posible establecer ninguna estructura en null, y Nullable<T> no es una excepción. En su lugar, el compilador traduce una solicitud para establecer Nullable<T> en null como una solicitud para establecer el campo "tiene valor" (reflejado en la propiedad HasValue) en falso y establecer el campo "valor real" (reflejado en la propiedad Value) en el valor predeterminado su tipo.

personalmente, creo que pretender que un Nullable<T> donde HasValue es falso es null es más confuso que útil, pero no estoy Microsoft.Yo creo que habría sido más útil para cada tipo Nullable<T> que tiene una propiedad estática Nullable<T>.Null (lo que equivaldría a default(Nullable<T>), pero el comportamiento de Nullable<T> es lo suficientemente bien establecida Dudo que alguna vez va a cambiar.