這篇文章主要介紹了C#基礎語法：可空類型詳解,本文分析了可空類型的源碼、研究了可空類型強制轉換為常規類型、可空類型的運算等內容,需要的朋友可以參考下
以下是System.Nullable
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57[Serializable, StructLayout(LayoutKind.Sequential)]
public struct Nullable
{
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
{
return new Nullable
}
}
可以看出 null 的類型的每個實例都具有兩個公共的只讀屬性：
1.HasValue
HasValue 屬於 bool 類型。當變量包含非 null 值時，它被設置為 true。
2.Value
Value 的類型與基礎類型相同。如果 HasValue 為 true，則說明 Value 包含有意義的值。如果 HasValue 為 false，則訪問 Value 將引發 InvalidOperationException。
那麼我們怎麼定義可空類型?
null 的類型可通過下面兩種方式中的一種聲明：
代碼如下:
System.Nullable
- 或 -
T? variable
T 是可以為 null 的類型的基礎類型。T 可以是包括 struct 在內的任何值類型;但不能是引用類型。
現在舉一個例子，運用一下看看效果是不是一樣。
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22Console.WriteLine("========可空類型操作演示========n");
Console.WriteLine("n=========Nullable
Nullable
Nullable
Nullable
Nullable
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#代碼：
代碼如下:
privatestatic Nullable
{
Nullable
Nullable
if(!(nullable1.HasValue & nullable2.HasValue))
returnnew Nullable
else
returnnew Nullable
}
??運算
假如左邊的操作數不為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
具體地說，當CLR對一個Nullable
代碼如下:
//對Nullable
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
代碼如下:
//創建一個已裝箱的int
object o =5;
//把它拆箱為一個Nullable
int? a = (int?)o; //a=5
int b = (int)o; //b=5
//創建初始化為null的一個引用
o =null;
//把它“拆箱”為一個Nullable
a = (int?)o; //a=null;
b = (int)0; //拋出NullReferenceException
將一個值類型拆箱為值類型的一個可空的版本時，CLR可能必須分配內存。這是極其特殊的一個行為，因為在其他所有情況下，拆箱永遠不會導致內存的分配。原因在於一個已裝箱的值類型不能簡單的拆箱為值類型的可空版本，在已裝箱的值類型中並不包含 hasValue字段，故在拆箱時CLR必須分配一個Nullable< T>對象，以初始化hasValue = true ,value = 值類型值。
調用接口方法
下面的代碼中，將一個Nullable
代碼如下:
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 對象。
