内置类型

内置类型是一些有关键字表示的类型。关键字具有非常高的优先级，可以让你在没有别的配置的情况下，
只要用的是c#就可以使用。这也意味着这些类型是非常重要，或是基本的东西。

• 整数：byte, sbyte, short, ushort, int, uint, long, ulong
• 浮点数：float, double, decimal
• 布尔：bool
• 文字：char, string
• 其他：object, dynamic

整数类型

整数类型一共有8种。他们的区别的所占的字节数，和有没有储存符号。

内容	1字节	2字节	4字节	8字节
有符号	sbyte	short	int	long
无符号	byte	ushort	uint	ulong

以byte为例子。他占1字节，所以有8位。一共能表示2的8次方种情况。所以他一共能表示256个数。
由于最小的是全0的情况，这时候数字就是0。从0开始数256个数，只能数到255。
所以他的计数范围是0到255。

一个字节（byte）有8个比特（bit）。比特和位是同义词。在计算机的语境下，这里的位都是二进制计数。
二进制数数起来像这样：0（0）,1（1）,10（2）,11（3）,100（4）,101（5）,110（6）,111（7）,1000（8）。
可以看到这里面的每一位数都跟2的次方有联系。

而sbyte也是1字节8比特。区别在于拿出了1位表示符号。他也能表示256个数，但是范围纳入了负数。
他的计数范围是-128到127。

所以，最常用的int类型，32位，有符号，计数范围就是-21亿到21亿。

short意思是短，long的意思是长。他们刚好是int类型的一半和翻倍。
而int是integer的缩写。integer的意思是整数。

浮点数

浮点数的意思是，小数点可以浮动（不固定）。这种计数方式是从科学计数法得到的灵感。
例如120000，可以表示为12*10的4次方。可以说把一个整数12，的小数点向右移动4位数，就得到了120000这个数。
而缺点，科学计数法本身也没有精确计数的意思。浮点数可以表示小数和很大的数，但精确度有限。
比如300万+1/300万，是加不上去的。

浮点数的计数范围计算比较复杂，只列出结果。

关键字	中文	比特	上限	精度
float	单精度浮点类型	32	3.4E+38	223
double	双精度浮点类型	64	1.79E+308	252
decimal	十进制浮点数	128	7.92E+28	296

布尔

乔治·布尔是一位英国数学家，他创立了布尔逻辑，使得不同的逻辑表达式有了一种通用的数学运算方式。
布尔值只有两个值，真（true）和假（false）。这两个值的主要作用就是逻辑计算，也就是用于布尔逻辑。

文字

char类型表示一个字符。在c#中使用utf-16编码储存。每个char只能表示一个字符，不能多也不能少。
string类型表示一堆字符。可以多，也可以一个字符都没有。

其他

object，是c#中所有类型的根源，他作为变量时可以存储任何值。
（但这个类型没有职责，所以他即不能像数字一样运算，也不能像文字一样裁剪）。

dynamic，动态类型。为了可以储存所有值，他也是使用object储存值。但他会让编译器尝试执行你代码中的职责。

object o = 12;
dynamic d = 12;
int i = 12;Console.WriteLine(o + 12);//objcet类型没有数学运算的职责，编译器会对这个要求报错
Console.WriteLine(d + 12);//编译器不会检查动态类型的职责。但如果运行时确实无法履行这个职责，则报错
Console.WriteLine(i + 12);//正规的数字类型，他可以进行数学运算

字面量

字面量是源代码中用来直接表达固定值的一种表示法，它与一般的值不同，不需要进行构造。

整数的字面量

自动类型

通常情况下，整数的字面量都是int类型。
但是，如果超出int的范围，会逐步变为long，ulong类型。
如果再超出则会报错。

var i1 = 100;//int
var i2 = 10000000000000000;//long
var i3 = 10000000000000000000;//ulong
var i4 = 100000000000000000000000000000000000000;//报错

如果你没有按照前章节的操作打开类型提示，可以将鼠标悬浮在变量名上查看类型。

强制类型

在数字的后面可以加后缀，使得强制变为某种类型

• u:uint或ulong，基于当前常量的大小
• L:long
• ul：强制为ulong类型

后缀的大小写不限，但为了和数字1区分开，在使用L后缀时通常使用大写。
后缀的顺序不限，虽然只有ul会有顺序。

var i5 = 100u;//uint
var i6 = 10000000000000000u;//ulong
var i7 = 100L;//long
var i8 = 10000uL;//ulong

2进制和16进制

在数字的开头加上0b，可以让这个数字以2进制的方式构造字面量。
在数字的开头加上0x，可以让这个数字以16进制的方式构造字面量。

var i9 = 0b10000;
var i10 = 0x1a;
Console.WriteLine(i9);//16
Console.WriteLine(i10);//26

分隔

为了防止数字过大的时候数不清，可以添加下划线_来作为分割符。
下划线可以随意使用，不限位数，也能连续使用。但是必须用在数字的之间，不能在开头和结尾。

var i11 = 1_000_000;
var i12 = 100_000;
var i13 = 1_0__0___0_____0______0;

浮点数的字面量

强制类型

无修饰的浮点数字面量始终是double类型。
可以在后面加上f改为float类型，或是在后面加上m改为decimal类型。
是如果用的就是整数字面量，也可以加上d来改为double类型。

var f1 = 12f;
var f2 = 12.0f;
var d1 = 12d;
var d2 = 12.0;
var m1 = 12m;
var m2 = 12.0m;

省略整数部分

浮点数需要带上小数点，或是后缀才能视为浮点数。
小数点后面必须有至少一个数字，可以是全0。但小数点前面的数字是可以省略的。

var d3 = 0.0;
var d4 = .0;

科学计数法

浮点数可以使用字母e的科学计数法表示数。
但不像科学计数法要求前面的值在1到10之前。

var d5 = 1e4;//10000
var d6 = 12e-2;//0.12
var d7 = 0e9;//0

分隔

和整数一样可以使用下划线分隔。但是如果有小数点，分隔不能出现在小数点前面。

布尔的字面量

布尔值的字面量只有两个，他们都是关键字：true和false。

var b1 = true;
var b2 = false;

文本的字面量

字符的字面量使用一对单引号包围，不能多也不能少。
字符串的字面量使用一对双引号包围，可以任意长，包括没有值。但是字面量不能包含换行。

var c1 = 'a';
var c2 = '好';
var s1 = "";
var s2 = "你好世界";

转义

由于这两种引号都被我们用来表示字面量的范围，因此我们想在文本字面量里表示引号是很困难的。
为了可以表示引号，换行等一系列特殊字符，需要使用转义。
转义使用反斜杠\（退格键和回车键附近）开始，他跟接下来的特定组合会合并为一个字符。

例如表示引号，反斜杠自身，都是在反斜杠后加上他们自身。

var c3 = '\'';//会输出'
var s3 = "\"\\";//会输出"\

而其他的常见组合有

• \n：换行
• \t：水平制表符
• \uxxxx：直接转义一个unicode编码

var c4 = '\u5238';//输出卷
var s4 = "1\t1\n11\t1\n111\t1\n1111\t1";//水平制表符可以根据以及用的字符数量，自动决定生成多少个空格
Console.WriteLine(s4);

转义组合的字符，会有特殊的颜色。

原始字符串

有的时候，我们会从其他地方复制东西过来。
从文件路径复制来的文字中，含有大量反斜杠。
从网页源码复制来的文字中，含有大量引号。

为了便于修改，可以使用原始字符串。原始字符串会无视内部的所有转义，以原样生成。
原始字符串使用3个或更多的双引号开头，以相同数量的引号结尾。

Console.WriteLine("""C:\Program Files\dotnet\packs""");
Console.WriteLine("""""用户输入{""""}""""");//如果字符里面的连续引号过多，就增加原始字符串首尾引号数量，直到文本中的引号不会有歧义。

在使用多行原始字符串时，首尾的引号必须单独放置在一行，不能包含内容文字。
首末行不会被记录一个换行。结束引号的前面有多少个空格，文本就会裁剪等量的前导空格。
内容行首不能超过收尾引号。

string s5 = """宽度=480px;高度=640px;""";
Console.WriteLine(s5);

指定类型的变量声明

不一样的类型

使用var创建的变量，总是会识别右侧值的类型。
但有时候，声明的变量类型可能不希望跟值的类型完全一样。
例如，字面量无法生成byte类型的数字。必须使用指定类型声明。

byte b = 12;

分开声明和赋值

使用指定类型声明变量，可以不需要在第一次声明的时候就赋值。
但在第一次使用之前需要赋初始值。

int i;
i = 12;

同时声明

使用指定类型，可以在一条语句里声明多个变量，只需要用逗号隔开变量名。

object o1, o2, o3, o4;

类型转换

隐式自定义类型转换

一些类型之间写了类型转换的方式。例如从char到int。
他们本来没有兼容，但是源码写了从char到int的转换方式，所以可以转换。
而char没有写到string的转换，所以即便他们很像也不能把char值赋值给string变量。

int i14 = 'a';//会得到这个字符的编码
string s7 = 'a';//报错

字符的储存是列一张表。规定数字1对应字符a，数字2对应字符b这样子。
这张表就叫字符集。把char值赋值给int变量会得到他的编码。
char类型是utf-16编码储存，也就是说是一个无符号16比特数据，跟ushort一样。

显式自定义类型转换

有些不兼容的类型，写了显示转换。
这种转换方式需要多一个步骤，在前面用括号写上目标类型。
这个作用是告诉你，结果可能不是你想要的，小心点。

double d8 = 6.8;
int i15 = (int)d8;//会得到6。小数不会四舍五入，而是完全舍去。

所有隐式转换都可以以显示转换的方式写。有效，但没意义。

基于继承的类型转换

一个类型继承另一个类型时，会获得他的全部职责。那么，就可以当作那个类型使用。
（香蕉类型继承自水果类型。水果能干什么香蕉就能干什么）
所以作为所有类型的基类object，没有设置过多的职责。

object o5 = 12;

继承关系是真正的类型兼容，自定义转换不能指定有继承关系类型的转换。

基于派生的类型转换

int继承自object，所以一个object值有可能是int值。
这种转换同样要在前面加括号写上目标类型，说明可能出错。

object o5 = 12;
int i16 = (int)o5;//o5确实是int类型。
string s7 = (string)o5;//o5不是string类型，int也没有对string的兼容。会出错。

工厂设计模式构造值

工厂模式是说根据配置的不同，创造出不同的值。
屏幕识图根据图片（配置）识别出文字（创造值）就是一种工厂模式。
类似的，把文字转化为数字，也可以使用工厂方法。

所有数字类型都有一个Parse方法，接收一个字符串，来构造一个数字。

int i17 = int.Parse("60");
double d9 = double.Parse("2.5");
Console.WriteLine(i17*d9);

用于识别的字符串必须是有效的数字，例如有不是数字的东西（开头表示正负的+-除外），
或者整数类型去识别一个小数，或者识别了超出自己范围的数字都会出错。