c# - has - public nullable int
¿Dónde en la memoria se almacenan los tipos anulables? (4)
Esta es quizás una pregunta complementaria sobre tipos anulables .
¿Dónde se almacenan exactamente en la memoria los tipos de valores anulables ( int? ...)? Primero pensé que estaba lo suficientemente claro, ya que Nullable<T> es struct y esos son tipos de valor. Luego encontré el artículo de Jon Skeet " Memory in .NET ", que dice:
Tenga en cuenta que una variable de tipo de valor nunca puede tener un valor nulo; no tendría ningún sentido, ya que nulo es un concepto de tipo de referencia, lo que significa que "el valor de esta variable de tipo de referencia no es una referencia a ningún objeto" .
Estoy un poco confundido después de leer esta declaración. Así que digamos que tengo int? a = null; int? a = null; . Como int es normalmente un tipo de valor, ¿se almacena de alguna manera dentro de la estructura Nullable<T> en la pila (usé "normalmente" porque no sé qué sucede con el tipo de valor cuando se convierte en nullable)? ¿O algo más sucede aquí, tal vez en el montón?
Además de la respuesta de Kevin: el compilador conoce los tipos de Nullable y cambia un ==null cheque ==null en una llamada a ".HasValue".
En primer lugar, Nullable<int> es solo una abreviatura de algo como:
struct Nullable<T>
{
bool hasValue;
T value;
}
Además de todos los constructores, accesores, etc. Eso es todo lo que es: un int anulable es un int ordinario más una bandera que dice si el int es nulo o no. Todo lo demás es magia de compilación que trata "nulo" como un valor válido; Todo lo que "null" hace con un tipo de nullable es que te hace una de esas estructuras con el indicador establecido en falso.
Así que ahora que ya hemos dejado de lado, tu pregunta es "¿a dónde van en la memoria"? Van al mismo lugar que cualquier otra estructura en la memoria: donde el tiempo de ejecución y el compilador creen que es el mejor lugar dada la vida útil de la memoria.
La mayoría de las estructuras van en el montón. Cualquiera que te diga que "las estructuras siempre van en la pila" no sabe realmente de qué están hablando; Nuestra documentación no dice eso y no es verdad. Las estructuras solo se colocan en el grupo de memoria temporal, también conocido como "la pila", cuando son variables locales o temporales, y las variables locales no se cierran sobre las variables externas de un método anónimo o lambda, y las variables locales no están en un iterador bloquear. Todas las otras estructuras van en el montón en nuestra implementación.
Tenga en cuenta también que no hay ningún requisito de que una implementación de la CLI use "la pila" para hacer su grupo temporal. El administrador de memoria clásico de JScript, por ejemplo, almacena su grupo temporal en el montón. (Aunque, por supuesto, el motor de tiempo de ejecución de JScript no es una implementación de la CLI; simplemente estoy señalando que se puede diseñar un motor de tiempo de ejecución administrado que no coloque ningún tipo de datos de usuario en "la pila"). , pero esa estructura de datos no se almacena en "la" pila, es solo una estructura de pila asignada en el montón.
Tengo que preguntar: ¿por qué te importa? El CLR gestiona la memoria en su nombre. ¿Por qué te importa a dónde van los tipos anulables? Van a donde viven el tiempo suficiente para que te sean útiles; No tienes que preocuparte por eso.
Nullables solo pretende ser nulo:
int? a = null;
Debug.Assert((a == null) == (!a.HasValue));
El compilador es cómplice de esta farsa. Una consecuencia divertida de esto es la siguiente:
Nullable<double> b = new Nullable<double>();
Debug.Assert(b == null); //I''m null upon construction!
También reciben apoyo especial de boxeo:
int? c = null;
Object d = c;
Debug.Assert(d == null);
Debug.Assert(!c.HasValue);
Ver el comentario de Eric sobre dónde se almacenan las estructuras. Es mucho más exhaustivo (y correcto) de lo que publiqué.
La forma en que funciona es que el nullable tiene un valor booleano que indica si se ha establecido o no el valor. Técnicamente, usted es correcto, el nullable (int, bool), etc. no es realmente nulo. tiene un valor por defecto. es solo que ahora el tipo anulable tiene un valor booleano que puede verificar y ver si ese valor se estableció o es solo su valor predeterminado. Los valores = y == se anulan para establecer los valores apropiados al asignarle un valor null (y un valor)
Enlace de MSDN a Nullables
Otro enlace que describe cómo funcionan los elementos nulables:
http://www.markzhou.com/blog/post/2010/01/27/Why-can-assign-e2809cnulle2809d-to-nullable-types.aspx