c# - operator - ¿Cómo se implementan los tipos anulables bajo el capó en.net?

public nullable int

Question

En nuestro C # de Jon Skeet en profundidad , analiza las 3 formas de simular un ''nulo'' para los tipos de valor:

• Valor mágico (por ejemplo, el DateTime más temprano posible se toma como ''nulo'')
• Envoltura tipo de referencia
• bandera booleana

Se menciona que los tipos anulables utilizan el tercer método. ¿Cómo funcionan exactamente los tipos anulables bajo el capó?

Answer 1

En última instancia, son solo una estructura genérica con una bandera bool, excepto con reglas de boxeo especiales. Debido a que las estructuras están (por defecto) inicializadas a cero, el valor predeterminado de bool es falso (sin valor):

public struct Nullable<T> where T : struct {
    private readonly T value;
    private readonly bool hasValue;
    public Nullable(T value) {
        this.value = value;
        hasValue = true;
    }
    public T Value {
        get {
           if(!hasValue) throw some exception ;-p
           return value;
        }
    }
    public T GetValueOrDefault() { return value; }
    public bool HasValue {get {return hasValue;}}
    public static explicit operator T(Nullable<T> value) {
        return value.Value; }
    public static implicit operator Nullable<T>(T value) {
        return new Nullable<T>(value); }
}

Diferencias extra, sin embargo:

• Reglas especiales de boxeo (normalmente no puedes hacer esto)
• Reglas especiales de C # para comparar con null etc.
• operadores "levantados" en C # (y en .NET a través de EqualityComparer<T> , Comparer<T> etc.)
• reglas especiales sobre restricciones de tipo genérico (para evitar Nullable<Nullable<T>> )

Answer 2

Nullable<T> funciona al proporcionar dos campos:

private bool hasValue;
internal T value;

Las propiedades funcionan a partir de esos. Si lo establece en null , hasValue se establece en falso.