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 对象。

(0)

相关推荐

  • C#难点逐个击破(8):可空类型System.Nullable

    null与void null值用来表示数据类型未被赋予任何值,它是一种引用类型:void表示没有类型,或者说是没有任何值.null与void的区别可以认为void是根本没有,而null是一个空箱子,里面什么都没有. null值只能赋值给引用类型,这里注意到string也是一种引用类型:引用类型在C中称为"指针",即存放变量位置的内存空间位置.将变量设为null,会显式地设置引用,且它本身不指向任何内存位置: null值赋给值类型将导致编译错误. void用于方法值的返回,其本质并不是一

  • c#可空类型的作用说明

    可空类型用途主要是从数据库读取数据有可能为空,而不是插入使用,插入数据都要进行验证,如果要插入数据库的null,则使用DBNull.value 判断取出的数据是否为数据库中的null,如果是则赋值给可空的datetime类型的Lockdatatime 属性 tseat.Lockdatatime = reader.IsDBNull(5) ? null : (DateTime?)reader.GetDateTime(5); 判断取出的数据是否为数据库中的null,如果是则赋值给可空的int类型的Te

  • C# 可空类型分析

    例如,Nullable<Int32>,读作"可空的 Int32",可以被赋值为 -2147483648 到 2147483647 之间的任意值,也可以被赋值为 null 值.Nullable<bool> 可以被赋值为 true 或 false,或 null.在处理数据库和其他包含可能未赋值的元素的数据类型时,将 null 赋值给数值类型或布尔型的功能特别有用.例如,数据库中的布尔型字段可以存储值 true 或 false,或者,该字段也可以未定义. 可空类型具有

  • C#基础知识 全面解析可空类型

    引言: C# 2.0 中还引入了可空类型,可空类型也是值类型,只是可空类型是包括null的值类型的,下面就介绍下C#2.0中对可空类型的支持具体有哪些内容(最近一直都在思考如何来分享这篇文章的,因为刚开始觉得可空类型使用过程中比较简单,觉得没有讲的必要,但是考虑到这个系列的完整性,决定还是唠叨下吧,希望对一些不熟悉的人有帮助). 一.为什么会有可空类型 如果朋友们看了我之前的分享,对于这一部分都不会陌生,因为我一般介绍C#特性经常会以这样的方式开头的, 因为每个特性都是有它出现的原因的(有一句佛

  • C#中关于可空类型的小知识

    1) 在与1元或二元运算符一起使用时,如果其中一个操作数为null或两个均null,则结果为null. 如: 复制代码 代码如下: int? a = null; int? b = a+3; 则b为null 2) 比较可空类型时,只要有一个操作数为null,结果就为false 如: 复制代码 代码如下: int? a = null; int? b = 8; (a>=b)将返回false 而正是因为null的可能性,所以不能随意比较一个可空类型和一个非可空类型. 3) 空接合运算符 空接合运算符&quo

  • C#可空类型用法分析

    本文实例讲述了C#可空类型用法.分享给大家供大家参考.具体分析如下: 可空类型只能用于值类型,不能用于引用类型,引用类型本身支持null值. 如果直接把null赋值给int类型,会出现一个错误"无法将 NULL 转换成'int',因为它是一种值类型". 赋值时应该使用 int? a = null; 可空类型与一元或二元运算符一起使用是,如果一个操作数或两个操作数都是null,其结果为null. 说白了int?a=null 这句话的意思就是让值类型a可以接收null这个值 举例1 int

  • 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.ha

  • C#基础语法:方法参数详解

    ●值参数 :一个值参数相当于一个局部变量,当使用值参数的时候,将会分配一个新的存储位置,将实参拷贝到该位置,并将该拷贝值传递给该方法.因此,值参数只能将值带进方法,但是不能带出方法,而不会影响实参的值. ●引用参数:当使用引用参数的时候,将不会分配一个新的存储位置,In other words,引用参数能将值带进方法,也能带出方法,因而会影响实参的值.如下例: using System; namespace prg1 { class Paramstest { //值参数使用演示 public s

  • vue基础语法之插值表达式详解

    目录 一.vscode插件介绍 二.插值表达式介绍 三.插值表达式示例1 四.插值表达式示例2 五.插值表达式注意点 六.插值表达式补充 总结 一.vscode插件介绍 在我们演示插值表达式之前,我们先安装这一个VScode给我们提供的插件,它可以将我们书写好的网页通过服务端口的方式进行访问,同时它的好处还有:再修改代码后,不需要我们手动点击刷新,插件会帮我们自动进行刷新,是不是非常方便,提高了我们的开发效率,节省了我们每次修改代码都要点击一次刷新的操作. 安装步骤如下图所示:安装Live Se

  • Python基础之语法错误和异常详解

    目录 一.前言 二.异常 三.异常处理 3.1 try/except 3.2 try/except ... else 3.3 try-finally 四.抛出异常 4.1 raise 五.用户自定义异常 六.断言 assert 一.前言 Python assert(断言)用于判断一个表达式,在表达式条件为 false 的时候触发异常. 二.异常 即便 Python 程序的语法是正确的,在运行它的时候,也有可能发生错误.运行期检测到的错误被称为异常 三.异常处理 3.1 try/except tr

  • Django零基础入门之常用过滤器详解

    引言: 前面讲过了Django中使用模板变量.使用很简单,那么有没有什么关于模板变量的骚操作呢? 答案是肯定有的,这就是本文要讲的--过滤器! 1.过滤器 (1)纯干货讲解: 作用: 对变量进行过滤.在真正渲染出来之前,过滤器会根据功能处理好变量,然后得出结果后再替换掉原来的变量展示出来. 语法:{{ fruits|lower }} 管道符号进行链式调用(可以理解为嵌套使用!),比如实现一个功能,先把所有字符变成小写,再把第一个字符转换成大写. 语法:{{fruits|lower|capfirs

  • Go语言基础go接口用法示例详解

    目录 概述 语法 定义接口 实现接口 空接口 接口的组合 总结 概述 Go 语言中的接口就是方法签名的集合,接口只有声明,没有实现,不包含变量. 语法 定义接口 type [接口名] interface { 方法名1(参数列表) 返回值列表 方法名2(参数列表) 返回值列表 ... } 例子 type Isay interface{ sayHi() } 实现接口 例子 //定义接口的实现类 type Chinese struct{} //实现接口 func (_ *Chinese) sayHi(

  • mysql语法之DQL操作详解

    目录 简单查询 运算符查询 排序查询 聚合查询 分组查询 分页查询 一张表查询结果插入到另一张表 SQL语句分析 DQL小练习1 DQL小练习2 正则表达式 总结 DQL(Data Query Language),数据查询语言,主要是用来查询数据的,这也是SQL中最重要的部分! 简单查询 #DQL操作之基本查询 #创建数据库 CREATE DATABASE IF NOT EXISTS mydb2; #使用数据库 USE mydb2; #创建表 CREATE TABLE IF NOT EXISTS

  • javascript类型系统_正则表达式RegExp类型详解

    前面的话 前面已经介绍过javascript中正则表达式的基础语法.javascript的RegExp类表示正则表达式,String和RegExp都定义了方法,使用正则表达式可以进行强大的模式匹配和文本检索与替换.本文将介绍正则表达式的RegExp对象,以及正则表达式涉及 到的属性和方法 对象 javascript中的正则表达式用RegExp对象表示,有两种写法:一种是字面量写法:另一种是构造函数写法 Perl写法 正则表达式字面量写法,又叫Perl写法,因为javascript的正则表达式特性

  • Python 变量类型详解

    变量存储在内存中的值.这就意味着在创建变量时会在内存中开辟一个空间. 基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中. 因此,变量可以指定不同的数据类型,这些变量可以存储整数,小数或字符. 变量赋值 Python 中的变量赋值不需要类型声明. 每个变量在内存中创建,都包括变量的标识,名称和数据这些信息. 每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建. 等号(=)用来给变量赋值. 等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值. 例

  • Java基础之switch分支结构详解

    一.基本语法 二.流程图 1.画出 swtich 出流程 2.案例说明流程图 三.快速入门 案例:Switch01.java 请编写一个程序,该程序可以接收一个字符,比如:a,b,c,d,e,f,g a 表示星期一,b 表示星期二 - 根据用户的输入显示相应的信息.要求使用 switch 语句完成 代码: /* 案例:Switch01.java 请编写一个程序,该程序可以接收一个字符,比如:a,b,c,d,e,f,g a表示星期一,b表示星期二 - 根据用户的输入显示相应的信息.要求使用 swi

随机推荐