1）Nullable类型

一个Nullable类型就是基本类型加上一个“是否为null指示器”的合成类型。对于一个类型，如果既可以给它分配一个值，也可以给它分配null引用（表示没有任何值），我们就说这个类型是可以空的。因此，可空类型可表示一个值，或表示不存在任何值。例如，类似String的引用类型就是可空类型，而类似Int32的值类型不是可空类型。由于值类型的容量只够表示适合于该类型的值，因此它不可为空。

有些人认为int型变量的值为0就表示空，这是不对的，0也是它的值，而并不表示空。

看下面的代码演示：

 

1. static void Main(string[] args) 
2.         { 
3.             //int n = null; 
4.             //当直接给int类型赋值null时，编译器报错“无法将Null型转化为int型，因为它是一种不可以为null型的类型” 
5.             int? oneValue = null; 
6.             //定义Nullable类型和定义非Nullable类型非常相似，关键在于类型后面的修饰符“？” 
7.             //int? oneValue = 10; 
8.             if (oneValue.HasValue)//使用Nullable类型的HasValue属性来判定是否有值存储 
9.             { 
10.                 //int nNum = oneValue; 
11.                 //如果尝试获取oneValue的值，编译器就会报错 
12.                 Console.WriteLine(oneValue.Value); 
13.             } 
14.             else 
15.             { 
16.                 Console.WriteLine("oneValue的值为空！"); 
17.             } 
18.         } 

2)C#的溢出检查

 

当一种整型转换到另一种整型，这个过程取决于溢出检查上下文。checked关键字用于对整型算术运算和转换显式启用溢出检查，而unchecked关键字则用于取消整型算术运算和转换的溢出检查。

①启用溢出检查：当操作数的值在目标类型的取值范围内，则转换成功，否则将要抛出异常。

看下面代码演示：

 

1. class TypeConvert 
2.     { 
3.         static void Main(string[] args) 
4.         { 
5.             TypeConvert typeConvert = new TypeConvert(); 
6.             typeConvert.DoSomething(); 
7.         } 
8.  
9.         public void DoSomething() 
10.         { 
11.             //MyInt的值为2147483647 
12.             try 
13.             { 
14.                 int MyInt = int.MaxValue; 
15.                 byte MyByte = checked((byte)MyInt); 
16.             } 
17.             catch(OverflowException) 
18.             { 
19.                 throw; 
20.             } 
21.         } 
22.     } 

 

在代码中MyInt的最大值是2147483647，在强制转换为byte类型后，由于byte的取值范围为0-255，在这里使用了checked关键字进行了溢出检查，这里的byte型MyByte型无法容纳远大于其容量的值而抛出异常。

 

②取消溢出检查

在类型转换的过程中不检查数据是否超过目标数据类型的最大值，意味着类型转换永远是成功的。如果源数据类型的取值范围大于目标类型的取值范围，超过的部分将会被截取掉；如果源数据的取值范围小于目标类型的，转换后将使用符号或者零填充至与目标类型的大小相等；如果等于，则直接转换成目标类型

看实例代码如下：

1. class TypeConvert 
2.     { 
3.         static void Main(string[] args) 
4.         { 
5.             TypeConvert typeConvert = new TypeConvert(); 
6.             typeConvert.DoSomething(); 
7.         } 
8.  
9.         public void DoSomething() 
10.         { 
11.             //MyInt的值为2147483647 
12.             try 
13.             { 
14.                 int MyInt = int.MaxValue; 
15.         //byte MyByte = unchecked(byte)MyInt; 
16.         //这样写与下面的写法一样，区别就是生命了关键字 
17.                 byte MyByte = (byte)MyInt; 
18.         //这里没有使用溢出检查，结果也不会抛出异常。但是转换的结果是有问题的，是byte类型的最大值255，与原始的值相差很大。 
19.             } 
20.             catch(OverflowException) 
21.             { 
22.                 throw; 
23.             } 
24.         } 
25.     } 

 

 

③typeof运算符

typeof是一元运算符，用于返回任意一个类型的类型信息

typeof运算符的语法如下：  Type type=typeof（类型）;

示例代码演示如下：

1. class Program 
2.     { 
3.         static void Main(string[] args) 
4.         { 
5.             Type t = typeof(Program); 
6.             Console.WriteLine("方法："); 
7.  
8.             MethodInfo[] methodInfo = t.GetMethods(); 
9.             //返回该Type类型的所有公共方法 
10.             foreach (MethodInfo mInfo in methodInfo) 
11.             { 
12.                 Console.WriteLine(mInfo.ToString()); 
13.             } 
14.  
15.             Console.WriteLine("成员："); 
16.             MemberInfo[] memberInfo = t.GetMembers(); 
17.             //返回该Type类型的所有公共成员 
18.             foreach (MemberInfo mInfo in methodInfo) 
19.             { 
20.                 Console.WriteLine(mInfo.ToString()); 
21.             } 
22.  
23.             Console.ReadKey(); 
24.         } 
25.     } 

 

 

运行结果如下图：

 

 

④运算符的重载

运算符重载只能应用于类或结构。要重载一个运算符，可以声明一个名为operator X的方法并实现它，如operator +和operator -，一元运算符和二元运算符都可以被重载，相应地，重载方法分别带一个或者两个参数（类或者结构类型），其语法为：

  //一元运算符的重载        public static 自定义类型 operator 要重载的运算符（类型）        //二元运算符的重载        public static 自定义类型 operator 要重载的运算符（类型1，类型2）

注意：所有运算符的重载均是静态的方法，必须得用public修饰

代码示例如下：

 

1. class Program 
2.     { 
3.         public int Value { get;set; } 
4.  
5.         static void Main(string[] args) 
6.         { 
7.             Program o1 = new Program(); 
8.             o1.Value = 10; 
9.             Program o2 = new Program(); 
10.             o2.Value = 20; 
11.  
12.             Program o3 = o1 + o2; 
13.             Console.WriteLine(o3.Value); 
14.             Console.ReadKey(); 
15.         } 
16.  
17.         /// <summary> 
18.         /// 这里为Program类重载了“加（+）”运算符实现了两个对象的相加的功能，运算符的重载提高了编程的便利性 
19.         /// </summary> 
20.         /// <param name="o1"></param> 
21.         /// <param name="o2"></param> 
22.         /// <returns></returns> 
23.         public static Program operator +(Program o1, Program o2) 
24.         { 
25.             Program o = new Program(); 
26.             o.Value = o1.Value + o2.Value; 
27.             return o; 
28.         } 
29.     } 

 

     本文转自yisuowushinian 51CTO博客，原文链接：http://blog.51cto.com/yisuowushinian/1040068，如需转载请自行联系原作者