可空类型

以下是System.Nullable<T>在FCL中的定义。 

Code

 1 [Serializable, StructLayout(LayoutKind.Sequential)]
 2 public struct Nullable<T> where T :struct
 3 {
 4  private Boolean hasValue= false;
 5  internal T value= default(T);
 6 
 7 public Nullable(T value)
 8  {
 9 this.value= value;
10 this.hasValue= true;
11  }
12 
13 public Boolean HasValue {get {return hasValue; } }
14 
15 public T Value
16  {
17 get
18    {
19    if (!hasValue)
20        {
21       throw new InvalidOperationException("Nullable object must have a value.");
22        }
23      return value;
24    }
25  }
26 
27 public T GetValueOrDefault() {return value; }
28 public T GetValueOrDefault(T defaultValue)
29  {
30 if(!HasValue)return defaultValue;
31 return value;
32  }
33 
34 public override Boolean Equals(object other)
35  {
36 if(!HasValue)return (other== null);
37 if(other== null)return false;
38 return value.Equals(other);
39  }
40 
41 public override int GetHashCode()
42  {
43 if(!HasValue)return 0;
44 return value.GetHashCode();
45  }
46 
47 public override string ToString()
48  {
49 if(!HasValue)return "";
50 return value.ToString();
51  }
52 
53 public static implicit operator Nullable<T>(T value)
54  {
55 return new Nullable<T>(value);
56  }
57 }

 

 

---

 

可以看出 null 的类型的每个实例都具有两个公共的只读属性：

• HasValue

  HasValue 属于 bool 类型。当变量包含非 null 值时，它被设置为 true。

• Value

  Value 的类型与基础类型相同。如果 HasValue 为 true，则说明 Value 包含有意义的值。如果 HasValue 为 false，则访问 Value 将引发 InvalidOperationException。

 

---

 

那么我们怎么定义可空类型？

null 的类型可通过下面两种方式中的一种声明：

System.Nullable<T> variable

- 或 -

T? variable

T 是可以为 null 的类型的基础类型。T 可以是包括 struct 在内的任何值类型；但不能是引用类型。

现在举一个例子，运用一下看看效果是不是一样。

---

 

 

Console . WriteLine( "========可空类型操作演示========\n");
            Console . WriteLine( "\n=========Nullable<T>===========\n");
            Nullable < int > x = 5;
            Nullable < bool > y = false;
            Nullable < double > z = 5.20;
            Nullable < char > n = null;
            Console . WriteLine( "x.HasValue={0},     x.Value={1}" , x . HasValue , x . Value);
            Console . WriteLine( "y.HasValue={0},     y.Value={1}" , y . HasValue , y . Value);
            Console . WriteLine( "z.HasValue={0},     z.Value={1}" , z . HasValue , z . Value);
            Console . WriteLine( "n.HasValue={0},     n.Value={1}" ,n . HasValue , n . GetValueOrDefault());
            Console . WriteLine( "\n==============  T? ============\n");
            int? X = 5;
            bool? Y = false;
            double? Z = 5.20;
            char? N = null;
            int? [] arr ={ 1 , 2 , 3 , 4 , 5 }; //一个可空类型的数组
            Console . WriteLine( "X.HasValue={0},     X.Value={1}" , X . HasValue , X . Value);
            Console . WriteLine( "y.HasValue={0},     Y.Value={1}" , Y . HasValue , Y . Value);
            Console . WriteLine( "Z.HasValue={0},     Z.Value={1}" , Z . HasValue , Z . Value);
            Console . WriteLine( "N.HasValue={0},     N.Value={1}" , N . HasValue ,  N . GetValueOrDefault());
            Console . WriteLine( "\n================================\n");
            Console . ReadKey();

---

可空类型可强制转换为常规类型，方法是使用强制转换来显式转换或者通过使用 Value 属性来转换。从普通类型到可以为 null 的类型的转换是隐式的。例如：

 

int? a = 5; //int--->int?
double? b = a; //int?---->double?
int? c = ( int?)b; //double?---int?
int d = ( int) c; //int?---->int  不能隐式转换例如int d=c;则不能编译
int? e = null;
int f = e . Value; //可以编译但是会提示异常引发 InvalidOperationException

---

 

可空类型还可以使用预定义的一元和二元运算符（提升运算符），以及现有的任何用户定义的值类型运算符。如果操作数为 null，这些运算符将产生一个 null 值；否则运算符将使用包含的值来计算结果。例如：

---

 

 

 

int? a = 10;
int? b = null;
//一元操作符（+ ++  -- = - ! ~)
a++;        //a=11;
//二元操作符（+ - * / % & | ^ << >>) 
a *= 10;   //a=110;
//a = a + b;  //now a is null
//相等性操作符(== !=) 
if (b == null)
{
    b=b.GetValueOrDefault();
}
Console.WriteLine(a.Value);
a = a + b;
/*  if(a == null) ...  
* if(b == null) ...  
* if(a != b) ... */
//比较操作符 
if (a > b)
{
    Console.WriteLine("a>b");
}

---

下面总结下C#如何对操作符的用法：

　　1. 一元操作符（+ ++ - -- ！ ~）。如果操作数为null，结果为null。

　　2. 二元操作符（+ - * / % | ^ << >>）。两个操作数中任何一个为null，结果为null。

　　3. 相等性操作符（== !=）。如果两个操作数都为null，两者相等。如果一个操作数为null，则两者不相等。如果两个操作数都不为null，就对值进行比较，判断它们是否相等。

　　4. 比较操作符（< > <= >=）。两个操作数中任何一个为null，结果为false。如果两个操作数都不为null，就对值进行比较。

---

 

至此我在对上面代码的a=a+b解释一下，它实际等价于：

a = a . HasValue && b . HasValue ? a . Value + b . Value : ( int?) null;

 

---

 

在操纵可空实例时，会生成大量代码，如以下方法：

 

---

 

privatestaticint? NullableCodeSize(int? a, int? b)
{
    return a + b;
}

　　编译这个方法时，编译器生成的IL代码等价于以下的C#代码：

---

 

private static Nullable < int > NullableCodeSize(Nullable < int > a, Nullable < int > b)
{
Nullable < int > nullable1 = a;
Nullable < int > nullable2 = b;
if ( ! (nullable1.HasValue & nullable2.HasValue))
return new Nullable < int > ();
else
return new Nullable < int > (nullable1.GetValueOrDefault() + nullable2.GetValueOrDefault());
}

---

??运算

---

假如左边的操作数不为null，就返回这个操作数的值。如果左边的操作数为null，就返回右边的操作数的值。利用空接合操作符，可方便地设置变量的默认值。空接合操作符的一个好处在于，它既能用于引用类型，也能用于可空值类型。如下所示：

//===========可空类型=========

int ? b = null ;
int a = b ??520;

等价于：

// a = b.HasValue ? b.Value : 520

Console.WriteLine(x); //print: "520"

//===========引用类型=========

String s = GetstringValue();

String s= s ??"Unspecified";

等价于：

// String s = GetstringValue();
// filename = (s != null) ? s : "Unspecified";

---

装箱和拆箱转换

　　 假定有一个Nullable<int>变量，它被逻辑上设为null。假如将这个变量传给一个方法，而该方法期望的是一个object，那么必须对这个变量执行装箱，并将对已装箱的Nullable<int>的一个引用传给方法。但并不是一个理想的结果，因为方法现在是作为一个非空的值传递的，即使Nullable<int>变量逻辑上包含null值。为解决这个问题，CLR会在对一个可空变量装箱的时候执行一些特殊代码，以维护可空类型在表面上的合法地位。

具体地说，当CLR对一个Nullable<T>实例进行装箱时，它会检查它是否为null。如果是，CLR实际就不进行任何装箱操作，并会返回null值。如果可空实例不为null，CLR就从可空实例中取出值，并对其进行装箱。也就是说，一个值为5的Nullable<int>会装箱成值为5的一个已装箱Int32。如下所示：

---

// 对Nullable<T>进行装箱，要么返回null，要么返回一个已装箱的T
int ? n = null ;
object o = n; // o为null
Console.WriteLine( " o is null={0} " , o == null ); // "true"

n = 5 ;
o = n; // o引用一个已装箱的int
Console.WriteLine( " o's type={0} " , o.GetType()); // "System.Int32"

---

CLR允许将一个已装箱的值类型T拆箱为一个T，或者一个Nullable<T>。假如对已装箱值类型的引用是null，而且要把它拆箱为Nullable<T>，那么CLR会将Nullable<T>的值设为null。以下代码对这个行为进行了演示：

//创建一个已装箱的int
object o =5;

//把它拆箱为一个Nullable<int>和一个int
int? a = (int?)o; //a=5
int b = (int)o; //b=5

//创建初始化为null的一个引用
o =null;

//把它“拆箱”为一个Nullable<int>和一个int
a = (int?)o; //a=null;
b = (int)0; //抛出NullReferenceException

---

将一个值类型拆箱为值类型的一个可空的版本时，CLR可能必须分配内存。这是极其特殊的一个行为，因为在其他所有情况下，拆箱永远不会导致内存的分配。原因在于一个已装箱的值类型不能简单的拆箱为值类型的可空版本，在已装箱的值类型中并不包含 hasValue字段，故在拆箱时CLR必须分配一个Nullable< T>对象，以初始化hasValue = true ,value = 值类型值。

---

调用接口方法

　　下面的代码中，将一个Nullable<int>类型的变量n转型为一个IComparable<int>，也就是一个接口类型。然而，Nullable<T>不像int那样实现了IComparable<int>接口。C#编译器允许这样的代码通过编译，且CLR的校验器会认为这样的代码是可验证的，从而允许我们使用这种更简洁的语法：

int ? n = 5 ;
int result = ((IComparable)n).CompareTo( 5 ); // 能顺利编译和运行
Console.WriteLine(result);

　　如果CLR没有提供这一特殊支持，那就必须对已拆箱的值类型进行转型，然后才能转型成接口以发出调用：

int result = ((IComparable)( int )n).CompareTo( 5 );

---

可以使用 C# typeof 运算符来创建表示可以为 null 的类型的 Type 对象：

System.Type type = typeof(int?);

还可以使用 System.Reflection 命名空间的类和方法来生成表示可以为 null 的类型的 Type 对象。但是，如果您试图使用 GetType 方法或 is 运算符在运行时获得可以为 null 的类型变量的类型信息，得到的结果是表示基础类型而不是可以为 null 的类型本身的 Type 对象。

如果对可以为 null 的类型调用 GetType，则在该类型被隐式转换为 Object 时将执行装箱操作。因此，GetType 总是返回表示基础类型而不是可以为 null 的类型的 Type 对象。

---