C#基本語法：可空類型詳解。本站提示廣大學習愛好者：（C#基本語法：可空類型詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是C#基本語法：可空類型詳解正文
以下是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);
}
}
可以看出 null 的類型的每一個實例都具有兩個公共的只讀屬性：
1.HasValue
HasValue 屬於 bool 類型。當變量包括非 null 值時，它被設置為 true。
2.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#代碼：
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());
}
??運算
假設右邊的操作數不為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 對象。
