以下是System.Nullable<T>在FCL中的定义。
[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Nullable<T> where T :struct
{
private Boolean hasValue= false;
internal T value= default(T);
public Nullable(T value)
{
this.value= value;
this.hasValue= true;
}
public Boolean HasValue {get {return hasValue; } }
public T Value
{
get
{
if (!hasValue)
{
throw new InvalidOperationException("Nullable object must have a value.");
}
return value;
}
}
public T GetValueOrDefault() {return value; }
public T GetValueOrDefault(T defaultValue)
{
if(!HasValue)return defaultValue;
return value;
}
public override Boolean Equals(object other)
{
if(!HasValue)return (other== null);
if(other== null)return false;
return value.Equals(other);
}
public override int GetHashCode()
{
if(!HasValue)return 0;
return value.GetHashCode();
}
public override string ToString()
{
if(!HasValue)return "";
return value.ToString();
}
public static implicit operator Nullable<T>(T value)
{
return new Nullable<T>(value);
}
}
</div>
可以看出 null 的类型的每个实例都具有两个公共的只读属性：
1.HasValue
HasValue 属于 bool 类型。当变量包含非 null 值时，它被设置为 true。
2.Value
Value 的类型与基础类型相同。如果 HasValue 为 true，则说明 Value 包含有意义的值。如果 HasValue 为 false，则访问 Value 将引发 InvalidOperationException。
那么我们怎么定义可空类型？
null 的类型可通过下面两种方式中的一种声明：
System.Nullable<T> variable
- 或 -
T? variable
</div>
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();
</div>
可空类型可强制转换为常规类型，方法是使用强制转换来显式转换或者通过使用 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
</div>
可空类型还可以使用预定义的一元和二元运算符（提升运算符），以及现有的任何用户定义的值类型运算符。如果操作数为 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");
}
</div>
下面总结下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;
</div>
在操纵可空实例时，会生成大量代码，如以下方法：
privatestaticint? NullableCodeSize(int? a, int? b)
{
return a + b;
}
</div>
编译这个方法时，编译器生成的IL代码等价于以下的C#代码：
privatestatic Nullable<int> NullableCodeSize(Nullable<int> a, Nullable<int> b)
{
Nullable<int> nullable1 = a;
Nullable<int> nullable2 = b;
if(!(nullable1.HasValue & nullable2.HasValue))
returnnew Nullable<int>();
else
returnnew Nullable<int>(nullable1.GetValueOrDefault() + nullable2.GetValueOrDefault());
}
</div>
??运算
假如左边的操作数不为null，就返回这个操作数的值。如果左边的操作数为null，就返回右边的操作数的值。利用空接合操作符，可方便地设置变量的默认值。空接合操作符的一个好处在于，它既能用于引用类型，也能用于可空值类型。如下所示：
//===========可空类型=========
int? b =null;
int a = b ??520;