C#筆記 – 可空類型

為甚麼值類型變量不能是空

• 非空引用值提供一個訪問對象的路徑，null引用等同「我不引用任何對象」

  • 在內存空間中，引用類型的表示是全零（引用地址）。本質上與其他引用的存儲方式是一樣的。

• 值本身由一個字節組成

  • 可以將值0-255存儲到變量中。

  • 如果我們在這基礎上加一個位元表示null，總共就要257個位，沒有辦法用一個字節存儲這麼多的值。

C# 1表示空值的方法

• 魔值

  • 犧牲一個值來表示空值，如Int.MinValue

  • 魔值不浪費任何內存

  • 同時該值將永遠不能被用來表示真正的數據

• 引用類型包裝

  • 方法一：用object作用變量類型，根據需要進行裝箱/拆箱

  • 方法二：假定值類型A可空，就為它準備一個引用類型B。在引用類型B中，包含值類型A的一個實例變量，並在B中聲明一個隱式轉換操作符。

  • 允許直接使用null

  • 要求在堆上創建對象，可能導致GC困難、內存消耗增加

• 額外的bool

  • 將值和bool封裝到另一個值類型中

    • 由於也是值類型，因此可以避免GC

    • 通過封裝的值內表示可空性，而不是通過空引用表示

  • 針對每一個值類型創建一個新的類型

  • 如果值因為某種原因要進行裝箱，那不管它是否被認為是空值，都要像平時那樣進行裝箱

System.Nullable（泛型）

• public struct Nullable<T> where T : struct
  {
      public Nullable(T value);
      public bool HasValue { get; }
      public T Value { get; }
      
      [NullableContextAttribute(2)]
      public override bool Equals(object? other);
      public override int GetHashCode();
      public T GetValueOrDefault();
      public T GetValueOrDefault(T defaultValue);
      [NullableContextAttribute(2)]
      public override string? ToString();
      public static implicit operator T?(T value);
      public static explicit operator T(T? value);
  }

• Nullable（可空類型）是一個泛型類型

  • 對於任何具體可空類型而言，T的類型稱為可空類型的基礎類型（underlying type）

    • Nullable的基礎類型為int

    • Nullable<T>仍然是值類型，所以實例仍然是在棧上

    • 在C#中，在值類型後跟上”?”使之等價於對應的可空值類型

      • int? a;
        Nullable<int> a;

      • 以上兩者相互等價

• Nullable的屬性

  • HasValue

  • Value

  • 另外，由於Nullable仍然為值類型，因此對於Nullable類型的變量來說，其值將直接包含一bool（HasValue）和 int（Value），而不會是其他對象的引用

• Nullable的方法

  • 構造方法：可指定值決定要不要創建一個有值的實例

  • GetValueOrDefault：如果實例存在值，就返回該值，否則返回一個默認值

  • GetHashCode/ToString等重載

    • GetHashCode在沒有值時返回0

    • ToString在沒有值時設回空字符串

  • 轉換方法

    • 非可空類型T轉換到可空類型T的隱式轉換

      • 轉換結果為一個HasValue == true的實例

    • 可空類型T轉到到非可空類型T的顯式轉換

      • 沒有可以返回的Value時拋出異常

    • 將T的實例轉換成Nullable的實例稱為「包裝」

      • int a = 5;
        Nullable<int> b = a;

    • 將Nullable的實例轉換為T的實例稱為「拆包」

      • Nullable<int> a = 5;
        int b = (int)a;

  • 比較方法

    • 來自靜態類Nullable（非泛型）的兩個靜態方法

      • 對於沒有值的實例，比較方法的返回值遵從.NET的約定：空與空相等；空小於所有值

      • public static int Compare<T>(Nullable<T> n1, Nullable<T> n2) //使用Comparer.Default
        public static bool Equals<T>(Nullable<T> n1, Nullable<T> n2) //使用EqualityComparer.Default

    • 來自Nullable（非泛型）的一個支持

      • public static Type GetUnderlyingType(Type nullableType)

      • 如果參數是可空類型，方法返回其基礎類型，否則返回null

Nullable（泛型）的裝箱和拆箱

• Nullable是一個struct（值類型），因此在進行引用類型操作時需要進行裝/拆箱

• Nullable的實例裝箱

  • 在沒有值時裝箱成空引用

  • 在有值時，等同將其值（非可空）裝箱

    • Nullable裝箱 = T裝箱

• 拆箱：已裝箱的值可拆箱成普通類型/對應的可空類型

  • 拆箱一個空引用時

    • 只能拆成可空類型，否則報錯

    • 空引用拆成可空類型後，會拆成一個沒有值的實例

      • 如果對已裝箱值類型的引用是null，而且要把它拆箱成一個Nullable<T>，CLR會將Nullable<T>的值設為null

Nullable（泛型）實例的Equals(object)

• 設有一可空值類型first，一可空/非可空值類型seconds，first.Equals(second)在不同情況下的結果：

  • 不必考慮second是否一個Nullable，基於Equals(object)的參數類型object將會對second進行裝箱。

    • 當second有值時，會裝箱成一個非可空值類型的箱子

    • 當second沒有值時，會返回一個空引用

  • if(first.HasValue && second == null) => first == second

  • if(first.HasValue && second != null) => first != second

  • if(!first.HasValue && second == null) => first != second

  • if(first.Value == second) => first == second

語法糖

• ? 修飾符

• • 使用?修飾符修飾的值類型變量與使用Nullable聲明的變量會被編譯成同樣的IL（System.Nullable`1[T]）

  • Nullable<int> a = 10; //IL : System.Nullable`1[System.Int32]
    int? a = 10; //IL : System.Nullable`1[System.Int32]

• 使用null進行賦值和比較

• • 設有一個Person類

    • 類中有一個可空類型：死亡日期

      • static void Main(string[] args)
        {
            Person turing = new Person("Alan Turing", new DateTime(1912, 6, 23), new DateTime(1954, 6, 7));
            //將null當作可空類型的實例來傳遞時，實際上是通過調用不可空類型的構造函數，為這個類型創建空值
            Person knuth = new Person("Donald Knuth", new DateTime(1938, 1, 10), null);
            Console.ReadKey();
        }  
        
        public class Person
        {
            DateTime birth;
            DateTime? death;
            string name;
            
            public TimeSpan Age
            {
                 get
                {
                     //當將可空變量同null進行比較時，實際上是在裡面的hasValue屬性
                     if (death == null) { return DateTime.Now - birth; }
                     else { return death.Value - birth; }
                }
            }
        
            public Person(string name, DateTime birth, DateTime? death)
            {
                 this.name = name;
                 this.birth = birth;
                 this.death = death;
            }
        }

    • 對IL代碼的觀察

      • //if(death == null)
        //調用HasValue屬性檢查death是否為空
        IL_0007:  call       instance bool valuetype [System.Runtime]System.Nullable`1<valuetype [System.Runtime]System.DateTime>::get_HasValue()

      • //在將null作為DateTime?類型的實參傳遞時
        //Person knuth = new Person("Donald Knuth", new DateTime(1938, 1, 10), null);
        //實際上是調用Nullable的默認構造方法（Initobj）
        //有參構造方法的調用是newobj
        IL_003e:  initobj    valuetype [System.Runtime]System.Nullable`1<valuetype [System.Runtime]System.DateTime>

      • IL_0001:  ldstr      "Alan Turing"
        IL_0006:  ldc.i4     0x778 //1912
        IL_000b:  ldc.i4.6 //6
        IL_000c:  ldc.i4.s   23 //23
        IL_000e:  newobj     instance void [System.Runtime]System.DateTime::.ctor(int32,
                                                                                    int32,
                                                                                    int32)
        IL_0013:  ldc.i4     0x7a2 //1954
        IL_0018:  ldc.i4.6 //6
        IL_0019:  ldc.i4.7 //7
        //創建普通的DateTime構造函數
        IL_001a:  newobj     instance void [System.Runtime]System.DateTime::.ctor(int32,
                                                                                    int32,
                                                                                    int32)
        //將上面的結果傳給下面這條有一個參數的Nullable的構造函數中
        IL_001f:  newobj     instance void valuetype [System.Runtime]System.Nullable`1<valuetype [System.Runtime]System.DateTime>::.ctor(!0)
        IL_0024:  newobj     instance void CSharpInDepth.Person::.ctor(string,
                                                                         valuetype [System.Runtime]System.DateTime,
                                                                         valuetype [System.Runtime]System.Nullable`1<valuetype [System.Runtime]System.DateTime>)

• 可空轉換和操作符

• • 假如一個非可空的值類型支持一個操作符或一種轉換，而且那個操作符或者轉換只涉及其他非可空類型時，那麼可空的值類型也支持相同的操作符或轉換

  • 并且通常是將非可空的值類型轉換成它們的可空等價物

  • 可空轉換

    • 已知的可空轉換

      • null -> T?（隱式）

      • T -> T?（隱式）

      • T? -> T（顯式）

    • 根據上述定義，以非可空類型int和long為例，他們之間有一系列的轉換操作，同樣地，可空類型int?和long?也有這些操作（這些涉及可空類型的轉換稱為「提升轉換」（lifted conversion）。

      • S? -> T? （顯/隱，取決於原始轉換）=>可空轉可空

      • S -> T?（顯/隱，取決於原始轉換）=>不可空轉可空

      • S? -> T（顯）=>可空轉不可空

  • 可空操作符

    • 當非可空的值類型T重載了操作符，可空類型T?將自動擁有相同的操作符，但操作數和結果類型稍有不同（這些操作符稱為「提升操作符」）