C#本质论读书笔记：第一章 C#概述|第二章 数据类型

第一章

1.字符串是不可变的：所有string类型的数据，都不可变，也可以说是不可修改的，不能修改变量最初引用的数据，只能对其重新赋值，让其指向内存中的一个新位置。

第二章

2.1 预定义类型或基本类型：

C#语言的基本类型包括8种整数类型，2种用于科学计算的二级制浮点类型，1种用于金融计算的十进制浮点类型，1种布尔类型以及一种字符类型。

2.1.1 整数类型：

要注意int32的范围，如果是要保存10位以上的数字编号的时候，要么使用string，要么使用int64，因为int32只能保存到10位，22 0000 0000都保存不了。

2.1.2 浮点类型：

有可能一个数被定义为0.1但是只是很接近0.1,而不是0.1

2.1.3 decimal类型：

精度为128位，浮点变为decimal的时候可能会发生溢出错误，因为decimal比float的范围小。

要显示具有完整精度的数字，必须将子面之显式的声明为decimal类型，要在数字后追加一个m或M，

decimal在范围之内表示的十进制整数都是准确的，但是浮点型则有误差。

2.1.4 string类型：

测试各种拼接：

1. namespace testDemo
2. {
3. classProgram
4. {
5. staticvoidMain(string[] args)
6. {
7. string a ="hello"+"wlz";
8. string b ="hello";
9. b +="wlz";
10. StringBuilder c =newStringBuilder("hello");
11. c.Append("wlz");
12. string d ="hello";
13. string.Concat(d,"wlz");
14. Console.Write(a);
15. }
16. }
17. }

IL的代码

1. .classprivateauto ansi beforefieldinit testDemo.Program
2. extends[mscorlib]System.Object
3. {
4. // Methods
5. .method private hidebysig static
6. voidMain(
7. string[] args
8. ) cil managed
9. {
10. // Method begins at RVA 0x2050
11. // Code size 74 (0x4a)
12. .maxstack 2
13. .entrypoint
14. .locals init (
15. [0]string a,
16. [1]string b,
17. [2]class[mscorlib]System.Text.StringBuilder c,
18. [3]string d
19. )
21. IL_0000: nop
22. IL_0001: ldstr "hellowlz"
23. IL_0006: stloc.0
24. IL_0007: ldstr "hello"
25. IL_000c: stloc.1
26. IL_000d: ldloc.1
27. IL_000e: ldstr "wlz"
28. IL_0013: call string[mscorlib]System.String::Concat(string,string)
29. IL_0018: stloc.1
30. IL_0019: ldstr "hello"
31. IL_001e: newobj instance void[mscorlib]System.Text.StringBuilder::.ctor(string)
32. IL_0023: stloc.2
33. IL_0024: ldloc.2
34. IL_0025: ldstr "wlz"
35. IL_002a: callvirt instance class[mscorlib]System.Text.StringBuilder[mscorlib]System.Text.StringBuilder::Append(string)
36. IL_002f: pop
37. IL_0030: ldstr "hello"
38. IL_0035: stloc.3
39. IL_0036: ldloc.3
40. IL_0037: ldstr "wlz"
41. IL_003c: call string[mscorlib]System.String::Concat(string,string)
42. IL_0041: pop
43. IL_0042: ldloc.0
44. IL_0043: call void[mscorlib]System.Console::Write(string)
45. IL_0048: nop
46. IL_0049: ret
47. }// end of method Program::Main
49. .method public hidebysig specialname rtspecialname
50. instance void.ctor () cil managed
51. {
52. // Method begins at RVA 0x20a6
53. // Code size 7 (0x7)
54. .maxstack 8
56. IL_0000: ldarg.0
57. IL_0001: call instance void[mscorlib]System.Object::.ctor()
58. IL_0006: ret
59. }// end of method Program::.ctor
61. }// end of class testDemo.Program

字符串类型的关键在于它是不可变的，可以对其重新赋值，但是不能修改其内容。

2.1.5 null

null只能赋给引用类型，指针类型和可空值类型。和根本不进行赋值相比，将null赋给一个引用类型完全是不同的概念。被赋值为null的变量已被设置，而未进行赋值的变量未被设置，此时在未赋值之前使用该变量，通常会造成一个编译时错误。同样的将null赋给一个string和将""赋给一个string也是不同的。

2.1.6 void

void不是一种数据类型，只是用于指出没有数据类型的这个事实。

2.1.7 var

用于声明隐式类型的局部变量，此时由编译器根据声明内部所赋的值来推断数据类型。

另外要在声明的同时进行赋值，负责会造成编译时错误，添加var的目的是支持匿名类型

例如：

C#代码：

1. var person =new{ name="wlz",phone="12346"};

IL代码：

1. [4]class'<>f__AnonymousType0`2'<string,string> person,
3. IL_004f: ldstr "wlz"
4. IL_0054: ldstr "12346"
5. IL_0059: newobj instance voidclass'<>f__AnonymousType0`2'<string,string>::.ctor(!0,!1)

2.2 类型的分类

2.2.1值类型

变量引用的位置就是值在内存中实际存储的位置，因此，将第一个变量的值赋给第二个变量将会在新变量的位置创建原始变量的值的一个内存副本，对第一个变量的值的更改不会影响第二个变量的值，值类型直接包含值。（用栈存储）

2.2.2引用类型

引用类型和引用它们的变量指向数据存储位置，引用类型只是存储一个内存地址，这个地址处才有真正的数据（用堆存储）“运行时”从变量中读取内存位置，然后跳转到包含数据的内存位置。将一个引用类型的变量赋给另一个引用类型的变量，只会多出地址的一个内存副本，此时两个不同的变量也可以引用相同的数据，一个变量对数据进行了修改也会改变另一个变量引用的数据，无论是赋值还是方法调用。

2.3可空修饰符

null值不能赋给一个值类型，但是我们在对数据库操作的时候，经常会碰到一个地方的数字缺失，这时候，我们肯定不能对这个数字赋给其他的值，这样就和数据库中的不一致了，这时我们可以使用可空修饰符？来声明可以存储null的变量。

c#代码：

1. int? nullNum =null;
2. int num =42;

IL代码：

1. [5] valuetype [mscorlib]System.Nullable`1<int32> nullNum,
2. [6]int32 num
4. IL_0060: ldloca.s nullNum
5. IL_0062: initobj valuetype [mscorlib]System.Nullable`1<int32>
6. IL_0068: ldc.i4.s 42
7. IL_006a: stloc.s num

2.4数据类型之间的转换

数据类型之间的转换分为两种，显式转换，隐式转换。

2.4.1显式转换

显式转换带来的后果由你自己承担，比如精度下降，数据丢失，数据未能成功转换时会报错。

1. int bigNum =int.MaxValue;//2147483647
2. int result = bigNum +1;
3. Console.WriteLine(result);//result的值是-2147483648

此处由于溢出使得result被截断了，因而变为了负数

1. .locals init (
2. [0]int32 bigNum,
3. [1]int32 result
4. )
6. IL_0000: nop
7. IL_0001: ldc.i4 2147483647
8. IL_0006: stloc.0
9. IL_0007: ldloc.0
10. IL_0008: ldc.i4.1
11. IL_0009: add
12. IL_000a: stloc.1
13. IL_000b: ldloc.1

关于显式转换这里，C#提供了checked和unchecked关键字，如果加上checked之后上面的代码在编译时会引发一个System.OverflowException（算术运算导致溢出。）

1.             checked
2. {
3. int bigNum =int.MaxValue-1;
4. int result = bigNum +1;
6. }

此时的IL代码变为下面的样子

1.         .locals init (
2. [0]int32 bigNum,
3. [1]int32 result
4. )
6. IL_0000: nop
7. IL_0001: nop
8. IL_0002: ldc.i4 2147483646
9. IL_0007: stloc.0
10. IL_0008: ldloc.0
11. IL_0009: ldc.i4.1
12. IL_000a: add.ovf
13. IL_000b: stloc.1
14. IL_000c: ldloc.1

此时由一开始的add变为了add.ovf,add.ovf较add多了一步，就是对两数相加之后执行溢出检查，没有问题才会将其放入栈。

C#中不支持数字变布尔值，0是真1是假，还是相反，不同的地方不同的情况。

2.4.2隐式转换

不会丢失数量级，也不会引发异常的转化即为隐式转换。

2.4.3不进行转型的类型转换

2.4.3.1parse方法

数值数据类型包含该方法

2.4.3.2System.Convert

这是一种类型，以前一直没注意到这一点。

2.4.3.3ToString()方法

2.4.3.4TryParse()方法

C#2.0开始出现，返回值不是对应的转换完成的值，而是是否成功。tryparse不会引发异常，parse则可能会。

C#代码

1.                 string text ="9.11E-31";
2. //Parse
3. float parseFloat =float.Parse(text);
4. float tryParseFloat;
5. //TryParse
6. bool successParseFloat =float.TryParse(text,out tryParseFloat);
7. //ToString
8. string floatToString=tryParseFloat.ToString();
9. string floatConvertToString=Convert.ToString(parseFloat);
10. Console.WriteLine(parseFloat);

IL代码

1.     .locals init (
2. [0]string text,
3. [1]float32 parseFloat,
4. [2]float32 tryParseFloat,
5. [3] bool successParseFloat,
6. [4]string floatToString,
7. [5]string floatConvertToString,
8. [6] bool CS$4$0000
9. )
11. IL_0000: nop
12. IL_0001: nop
13. IL_0002: ldstr "9.11E-31"
14. IL_0007: stloc.0
15. IL_0008: ldloc.0
16. IL_0009: call float32[mscorlib]System.Single::Parse(string)
17. IL_000e: stloc.1//将得到的值出栈（不是入栈）
18. IL_000f: ldloc.0
19. IL_0010: ldloca.s tryParseFloat
20. IL_0012: call bool [mscorlib]System.Single::TryParse(string,float32&)
21. IL_0017: stloc.3
22. IL_0018: ldloca.s tryParseFloat
23. IL_001a: call instance string[mscorlib]System.Single::ToString()
24. IL_001f: stloc.s floatToString
25. IL_0021: ldloc.1
26. IL_0022: call string[mscorlib]System.Convert::ToString(float32)
27. IL_0027: stloc.s floatConvertToString
28. IL_0029: ldloc.1
29. IL_002a: call void[mscorlib]System.Console::WriteLine(float32)
30. IL_002f: nop
31. IL_0030: ldloc.3
32. IL_0031: ldc.i4.0
33. IL_0032: ceq
34. IL_0034: stloc.s CS$4$0000
35. IL_0036: ldloc.s CS$4$0000
36. IL_0038: brtrue.s IL_0043

2.5数组

一维数组：

数组的声明：

1. string[] languages;

一维数组声明并赋值：

1. string[] languages={"C#","Java"};

声明之后再数组赋值：

1. string[] languages;
2. languages=newstring[]{"C#","Java"};

C#3.0起，不必在new后面指定数组的数据类型，但是方括号仍是需要的。

声明的同时使用new进行数组赋值：

1. string[] lanua =newstring[]{"C#","Java"};

在方括号中可以指定数组的大小，但是需要注意，数组的大小和大括号中的元素数量必须匹配。同时也可以分配一个数组但是不指定它的初始值，此时会使用默认值对这些数组元素进行填充。

二维数组：

1. int[,] table =newint[3,3];

不要丢了new

交错数组：

1.                 int[][] crosstable =
2. {
3. newint[]{1,0,2},
4. newint[]{3,2},
5. newint[]{1},
6. newint[]{}
7. };

交错数组不使用逗号来标识一个新的维度，而是定义一个由数组构成的一个数组

访问交错数组：

1. crosstable[2][2]=1;

要获取一个数组特定的维的长度，不要使用Length属性，而是应该使用GetLength()方法。

1. bool[,,] cells =new bool[2,3,4];
2. System.Console.WriteLine(cells.GetLength(2));//获取第三个维度,得到4
3. System.Console.WriteLine(cells.Length);//24

来自为知笔记(Wiz)