欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

C#基础语法:可空类型详解

程序员文章站 2024-02-06 11:19:16
以下是system.nullable在fcl中的定义。 [serializable, structlayout(layoutkind.seque...

以下是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 对象。