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         }

 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     }

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

 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     }

 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     }