Frage Wie sind Nullable-Typen unter der Haube in .net implementiert?


In unserem eigenen Jon Skeet's C # in der TiefeEr beschreibt die 3 Möglichkeiten, um eine 'Null' für Werttypen zu simulieren:

  • Magischer Wert (z. B. frühestmögliche DateTime wird als "Null" angenommen)
  • Referenztyp-Wrapper
  • Boolesche Flagge

Es wird erwähnt, dass Nullable-Typen die dritte Methode verwenden. Wie genau funktionieren nullbare Typen unter der Haube?


20
2018-03-23 21:36


Ursprung


Antworten:


Letztendlich sind sie nur eine generische Struktur mit einer Bool-Flagge - außer mit speziellen Box-Regeln. Da Strukturen (standardmäßig) auf Null initialisiert werden, ist der Bool-Wert standardmäßig false (kein Wert):

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); }
}

Extra Unterschiede, obwohl:

  • spezielle Boxregeln (das kannst du normalerweise nicht machen)
  • spezielle C # -Regeln zum Vergleich mit null etc
  • "hob" die Operatoren in C # (und in .NET via EqualityComparer<T>, Comparer<T> etc)
  • Spezielle Regeln für generische Typabhängigkeiten (um zu verhindern Nullable<Nullable<T>>)

35
2018-03-23 21:39



Nullable<T> arbeitet mit zwei Feldern:

private bool hasValue;
internal T value;

Die Eigenschaften arbeiten von diesen. Wenn Sie es einstellen null, hasValue wird auf false gesetzt.


4
2018-03-23 21:40