时间:2021-05-20
以下是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 在内的任何值类型;但不能是引用类型。
现在举一个例子,运用一下看看效果是不是一样。
可空类型可强制转换为常规类型,方法是使用强制转换来显式转换或者通过使用 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 对象。
声明:本页内容来源网络,仅供用户参考;我单位不保证亦不表示资料全面及准确无误,也不保证亦不表示这些资料为最新信息,如因任何原因,本网内容或者用户因倚赖本网内容造成任何损失或损害,我单位将不会负任何法律责任。如涉及版权问题,请提交至online#300.cn邮箱联系删除。
本文实例讲述了C#可空类型用法。分享给大家供大家参考。具体分析如下:可空类型只能用于值类型,不能用于引用类型,引用类型本身支持null值。如果直接把null赋值
引言: C#2.0中还引入了可空类型,可空类型也是值类型,只是可空类型是包括null的值类型的,下面就介绍下C#2.0中对可空类型的支持具体有哪些内容(最近一
在项目中我们经常会遇到可为空类型,那么到底什么是可为空类型呢?下面我们将从4个方面为大家剖析。1、可空类型基础知识顾名思义,可空类型指的就是某个对象类型可以为空
在c#中"??"为空合并运算符,用于定义可空类型和引用类型的默认值。(1)如果此运算符的左操作数不为null,则此运算符将返回左操作数;否则返回右操作数。例:a
扩展阅读c#基础系列1---深入理解值类型和引用类型c#基础系列2---深入理解String引言在上篇文章深入理解值类型和引用类型的时候,有的小伙伴就推荐说一说