前言
友友们好，本文为是 C# 入门的学习知识，包括笔者C#学习过程中的认识和心得。
这篇笔记整理花费一周时间，可以收藏拿来当作实际开发的 “划重点” 。由于内容中并不包含传统C语言本身的基础特性和基本语法，因此本文更适合有 C/C++ 基础的同学食用。或是有 C# 经验的小伙伴进行自查。
如果你对 C/C++ 感兴趣，或者在学习 C# 前需要想要了解大概的学习路线，可以参考我的另一篇博文：《C、C++、C# 我全都要！无痛学习经验分享》
初学难点提要
以下部分内容属于笔者初学时期略微难啃一点的内容，帮你挑出来了。建议同学们重点照顾：
5、命令行输入输出：Write相关内容
6、数据格式转换：Parse法，把字符串转化为对应的类型（比较容易忘）
9、二维数组（C#不同于 C/C++ 的表示方法）
11、值类型和引用类型
“Xiaochou x1” 不会调用构造，“Xiaochou x1 = new Xiaochou()” 才会
14、可变长参数 params 关键字函数
21、“只外部获取，不外部修改” 的成员变量——成员属性（成员变量的加强版）
这个章节要注意名为 name 和 Name 成员变量的区别，文章正文会体现
name：受保护的普通成员变量
Name：对外可访问的成员属性“接口”
23、索引器（属于高级语法）
public Person this [int index]
27、扩展方法
static class Add {
public static int IntAddOne(this int thisval) {
return thisval + 1;
}
}其中，对 Add 类有 static 要求，对 IntAddOne 有 public static 的要求。
其中的 this int， int 是扩充的那个类，任意变量名取什么都行。
29、分部类：partial，把一个类分成几部分声明 partial class Person
36、密封类 / 抽象类
环境搭建
一、新建项目
笔者使用的是VS2019，实测2015以上版本也可以兼容本篇内容。
进入修改，安装.NET桌面应用 → .NET SDK，之后再打开VS2019
二、新建解决方案下的项目
注意不是新建项=.=
是新建项目！项目！每个解决方案下可以新建多个项目
进入到如下示例程序，运行显示HelloWorld，则环境配置完毕。
笔记正文
1、学会两个最基本的快捷键——快捷注释
ctrl K+C 注释
ctrl K+U 去注释
F12 跳转到 函数/类/命名空间 的声明
2、认识代码块、函数块和命名空间
这个代码用来输出Hello World
引用了一个工具包 System，其中 System 是通过：
namespace System{ ... }这种方式定义的一个巨大的工具包，内部是各种系统自带的函数的声明。
3、查看函数或类的定义（F12）
当我们想查看一个函数或类的定义，可以选择它，按 F12 进行跳转。
4、region（代码块的折叠）
使用 region 指令，可以将一段代码折叠成一个独立的区域，这个区域可以包含多个代码块，例如类定义、属性、方法等。在 Visual Studio 中，可以通过单击左侧的减号来折叠或展开区域，也可以使用快捷键 Ctrl+M+M 来切换区域的折叠状态。
5、输入输出
Console.WriteLine("Hello World!");
string sin = Console.ReadLine(); // 等效于 cin <<
Console.WriteLine("OK"); // 等效于 cout <<
Console.ReadKey(); // 监听一个按键消息。如果有任何按键立刻释放阻塞
Console.WriteLine(" Detected.");6、数据类型转换
数据类型转换的本质不仅仅是将相同长度的数据放在不同的容器中，而且是根据数据类型的范围和精度要求进行的。在C#中，数据类型分为值类型和引用类型。
通常情况下，值类型的数据（例如 int、double、struct 等）可以直接进行类型转换。而引用类型的数据（例如class、interface、delegate）不建议用强制类型转换，因为转换的结果可能引发空指针。标准的转换方式是通过容器 as 成其他类型，这点在后续进阶过程中会学到。
具体的转换方法：
隐式转换：由编译器自动实现的默认转换。
显示转换：
1）强转，同C语言强转方法（在C#中较少使用）
2）Parse法，把字符串转化为对应的类型
语法： vartype.Parse("str") , eg： int.Parse("123");
string inp = Console.ReadLine(); // 等于 cin
Console.WriteLine(inp);
Console.WriteLine("result is:" + (int.Parse(inp)+1));
//输入123字符串，Parse成int，返回这个输入数+1的结果3）Convert 方法，普适方法，可以更精确乱转，还可以四舍五入
语法： Convert.ToXXX(data)
string和其他类型的互相转换：
string i = "6";
int a = Convert.ToInt32(i);
Console.WriteLine("result is:" + a);
float f = 1.233f; //注意C#要求必须写f作为小数后缀
string ret = Convert.ToString(f);
Console.WriteLine("result is:" + ret);4）其他变量转字符串： .ToString() 大法
float f = 1.233f;
Console.WriteLine("result :" + f.ToString());甚至于你可以写：
1.ToString()
这是因为 C#提供了一种简化的语法来调用 ToString()方法
7、异常捕获
最基本的：
以下代码中，当 try 中的代码执行异常时，会跳出 try 代码，转而执行 catch 的代码。
在没有使用 throw() 的情况下，try中的异常一般不会导致程序异常关闭。
try{
这里写我们要执行的
}
catch{
这里写如果异常，那么捕获异常的代码
}进一步的，我们可以使用进阶版的异常捕获代码。当发生异常时，exception e 可以被捕捉下来，编程者可以决定是打印输出或者存留到日志里。
try{
这里写我们要执行的
}
catch(exception e (用来捕获异常内容)) {
这里写如果异常，那么捕获异常的代码
throw; // 加上这句的效果是异常发生的时候抛出。
}
finally{
这句对不对都会执行，初步使用可以不用 finally
}8、字符串拼接
1）自动转换规则：如果一个string+int出现时，这个int 会自动 Tostring
str += 1; //不报错，结果是 str 的后面添1
2）字符串拼接规则
str += " " + 1 + 2 + 3; //结果是 123
str += 1 + 2 + 3 + " "; //结果是 6
str += 1 + 2 + " " + 3; //结果是 3 3
原因是 先计算运算符右边的，算完的部分会进行类型合并。X+string就是合并成string类型
3）Format拼接
string str = string.Format("我是{0}，我今年{1}岁", a, b);
9、一维数组，二维数组的定义
这部分定义的格式较为灵活，推荐大伙儿只掌握五种中的一种方法。
一维数组：
int[] arr1 = new int[] { 1, 2, 3 };
int[] arr2 = { 1, 2, 3, 4 };
//这两种都可以，感觉比较自由，注意不用C风格就好了二维数组：（注意只能用new进行预分配空间）
int[,] arr2 = new int[2,2];
arr2[0,0] = 1;C#在一维和二维数组的定义上采用了与C和C++不同的形式，主要是为了提供更好的类型安全性和可读性，并简化语法。
10、获取数组长度
// 获取数组的个数
int[] arr = new int[] { 1, 2, 3 };
int len = arr.Length;
// 获取数组某个维度的个数，入参dimension，一般用于高维数组的kkjk
int[] arr = new int[] { 1, 2, 3 };
int len = arr.GetLength(0);11、变量的值类型和引用类型
值类型：基本数据类型+结构体，值类型保存在栈空间里，在内存中的角色相当于“房间”
引用类型：类+数组。保存在堆空间，在内存中的角色相当于 “门牌号”
引用类型的变量在 arr2=arr1 之后，由于操作的是“地址引用的”
在改arr2[x]的时候，再去读arr1会发现改变了。
这是因为操作的具体内存是一个地址。
特殊的引用类型：string
其实在使用感受上，string认为是值类型其实也可以。
在申明string类型时候，系统会自动用临时变量分配一个string容器，不用担心门牌号问题。
12、VS调试和断点核心技能
遇到问题了怎么办？可以利用调试功能逐步看内存。
调试的功能比较庞大，初学我们只学习使用最简单的办法
调试四部曲：1）设置断点 2）运行 3）关注左下角自动/监视窗口 4）F10逐步
13、引用型变量的函数操作
下面这个函数在C#里，由于数组是引用规则，作为入参其结果居然会变（这点直观上与C/C++很大不同，但其实内因是一样的）
// Change函数
static void change(int[] arr)
{
arr[0] = 233;
return;
}
...
int[] arr1 = { 1, 2, 3 };
change(arr1);
//这个操作的结果是会把 arr1 的首项值 = 233；
本质原理：
图-引用类型的传参过程
笔者初学时，一时tm难以接受！经验证，值传递型不会有这个问题。
以下是值传递的验证代码：
static void change(int[] arr) {
arr = new int[] { 233, 233, 233 }; //不直接修改，而是new了一个！
return;
}
...
int[] arr1 = { 1, 2, 3 };
change(arr1);由于在函数内部重新对arr分配了一个新的 int[ ] 空间，导致原有的关系被破坏
这个和 int *p = malloc() 有所区别，但其内部设计思想类似。
13、ref （out 和 ref，二者使用方法几乎是一模一样的）
ref 等效于C++中函数参数的引用，相当于&，需要注意的是函数定义和使用都要加ref。eg:
static void change(ref int value)
{
value = 233;
return;
}
...
int origin = 0;
change(ref origin);ref 和 out的区别：out的传入变量必须在内部赋值，就是说函数 默认会对out参数修改值
ps：你要用out，就一定要改他； ref 的变量则是必须要经过初始化。
14、 可变长参数 params 关键字函数
必须是数组类型注意
int func(int a, char b, params int[] c)
然后params只能有一个，且放在最后
15、重载和返回值类型无关，只和参数有关
如果入参一样，尽管返回值不同仍然会有错误
注意一点，ref int 和 int 算是两种不同的入参类型，但是 ref int 和 out int 算是一种。
16、结构体在C#里不可以嵌套，也不准套娃
需要注意的几个点：
-
- C#的结构体是可以写构造和析构函数的，但是必须含参，因为无参构造默认生成了。
- C#的结构体是可以用 private 等修饰的 （学名访问控制符，默认为private）
- 结构体可以使用 this 关键字来引用当前对象。
结构体：
MyStruct stu1 = new MyStruct { "qingxiu", 23 }; // 这种初始化方法不可用
MyStruct stu1 = new MyStruct {age=23}; // 这种对劲儿，需要赋值时说明属性
MyStruct stu1 = new MyStruct(); // 这种也对劲，注意有一个()，初学者很容易忘
17、面向对象优点
清晰的逻辑关系，更高的效率、复用性和开发效率。
18、面向对象的三大特性（封装、继承、多态）和七大原则（偏理论）
这部分与编程的语言学习关系不大，有兴趣的同学自行检索即可。
这部分知识多归纳于 软件工程 和 设计模式 这两门课程，分布于国内大学的本科和研究生阶段。感兴趣的同学们可以从 MOOC 上补充这些知识。
19、有参构造函数的内容继承
+ :this() 继承无参构造函数的代码，以完成复用
同样的，可以是：有参构造函数 + :this(age+1) //继承有参构造函数的代码，且入参自定
eg:
class Person
{
private string name = "Default";
public Person() {
Console.WriteLine(this.name + " Created.");
}
public Person(string Name):this(){
this.name = Name;
Console.WriteLine(this.name + " Created.Append");
}
}最下方的 Person(string Name) 构造函数会继承 Person() 中的内容。
调用方法如下：
Person p1; // 注意，这只是申明变量，并没有new操作，所以不会调用构造
Person p1 = new Person(); // 调用无参构造
Person p1 = new Person("blabla"); // 调用无参构造+有参构造， 因为上文追加了:this()
20、自动垃圾回收机制GC
垃圾的定义：没有任何被引用的内容，需要被回收和释放
垃圾回收的过程：遍历每代堆上分配的所有对象。
从1代开始存，如果当前第n代存满就会触发GC，回收&重排前1~n代。
具体机制：
实际上是多级优先反馈队列的一个应用。GC运用了局部性原理。最终经常被引用的变量会升代，而大内存一开始就会在2代上。
手动触发GC：GC.Collect();
21、成员属性
“只外部获取，不外部修改” 的成员变量（属于高级语法）
背景：3P（private、protected、public）方式不便在外面定义一种约束。
private： 仅内访问
protected： 仅内、内子类访问
public： 内外访问
然后并没有那种 “仅外访问” 的，为了便于灵活的权限管理，产生了成员属性的需求。
成员属性的几个tips：
1）关键特征：对私有成员变量的专用 get{} 和 set{}。 这两个东西叫做“访问器”。
2）value关键字：代表入参
3）get和set可以只实现一个，二者也可以声明访问权限。
4）get和set可以被设计成 加密、控制访问权限等应用。
基本操作：
class Person
{
private string name = "Default";
public string Name{
get {
return name;
}
set {
name = value; // value关键字：简化代表为入参
}
}
....
调用：
p1.Name = "Yooo!";
Console.WriteLine(p1.Name); 扩展操作：存储加密
get{
return name - asdafs; // 这样在内存里就找不到存入的值了
}
set{
name = value + asdafs;
}扩展操作：把变量的访问权限设置为【单纯只想让外部访问，而不可修改】
public string Name{
get{
return name;
}
private set { }
}
或者简写为：
public string Name
{
get;
private set;
}效果：
22、如何表示 “一个Person 的 Person朋友们” ？
可以用以下代码表示：
class Person{
private string name;
private Person[] friends;
}23、索引器（属于高级语法）
让类对象可以像数组一样访问其中元素，观念上类似于重载了 "[ ]"
注意这里说是观念上。实际上C#不支持中括号的重载，并不能像C++那样广泛的重载。
class Person
{
public string name = "Default";
private Person[] friends;
public Person this[int index]
{
get {
return friends[index]; // p[0]:定义为第一个朋友
}
set {
if (friends == null) {
friends = new Person[10];
friends[0] = value; // value：入参
}
}
}
}
调用方法：
p2.name = "Amy";
p1[0] = p2; // 将p1的第0个朋友设置为 Name="Amy"的人tips：
1) public Person this [int index] // 这个格式是固定搭配：public 返回类型 this [params]
2) public Person this [int index, int age] // 索引器可以重载
24、静态成员 static
C#中的关键字 static，较为本质的理解可以说是 “将对应的成员放进静态区，从而在程序启动的开始进行加载”。
如果读者恰好学习过操作系统，也可以把 static 的成员想成是 “程序运行之初就已经分配好内存” 的成员。之所以可以这么理解，是因为static成员在被读取加载之后便没有办法动态操作，也不可以通过GC进行回收。
实际上，实例化的对象并不拥有静态成员，静态成员的所有者是他所在的类。我们通常把这部分变量直接用类名点出来使用，而不需要实例化对象！
static 变量会在程序运行时，由程序直接分配内存空间，二者同生共死，全生命周期
static 变量特性：1）全局性 2）直接 “.” 访问 3）程序运行时始终在特定内存段。
eg : 在 class TestClass 中，可以有如下变量：
1)
静态成员变量： static public float PI=3.1415926f; 可以 TestClass.PI
普通成员变量： public float PI=3.1415926f;
2)
静态成员方法： static public void TestFunc(); 可以 TestClass.TestFunc()
普通成员方法： public void TestFunc();
注意：static Func() 之中，不能使用 普通成员变量（非常重要，要懂原理）。因为 static Func() 在程序运行时就拥有了自己的内存，而普通成员变量必须进行实例化后才被分配内存。所以，是生命周期的问题导致了这个特点，实在要用就先实例化new一个。
同样，static 变量不会被 GC！静态分配会一直占着内存，分配大块内存要慎用static。
static 变量作用：1）常用于唯一量 2）想绕过实例化给别人用
static 方法的典型例子：1）不会被改变，且定义唯一的数学公式等
25、const 是特殊的 static
具有很多相同的性质
26、静态类：
1）不可实例化
2）具有唯一性
3）静态构造函数：第一次使用时调用，之后不再调用
eg：Console
27、扩展方法（有用！Must be public & static）
可以将一个 非static 的类中已有的方法进行外部拓展
比如可以给 Int32 类加一个你自己的方法。
特点：一定是个static类中的static函数，并且第一个参数是this修饰
class Person // 其中Person类没有任何除构造以外的成员方法
{}
// 定义扩展方法
static class AddFunc
{
// 意在对 Person 进行扩展
public static void Func(this Person obj, int val)
{ // obj：名字可以乱起，调用时是自动传入的，代表实例化的对象
Console.WriteLine("AddFunc:" + val);
}
}
// 调用
Person p1 = new Person();
p1.Func(233);在C#中，扩展方法必须声明为 static 才能正常工作。这是因为，扩展方法是一种静态方法，它不依赖于类实例，而是在整个应用程序中都可以使用的方法。
简言之，这个方法可以在不创建类的实例的情况下直接使用，如：1.ShowIntValue();
这里的1不需要我们进行 new int 操作，拿来就可以用。而且是在整个exe中使用。
28、运算符重载（Must be public & static）
注意，operator重载必须要将重载方法设置为类内static，且有返回值。
以下代码示例将二位数 (x,y) 添加相加规则：
class Point //
{
public int x;
public int y;
public static Point operator +(Point p1, Point p2) //记住格式！
{
Point temp = new Point(0, 0);
temp.x = p1.x + p2.x;
temp.y = p1.y + p2.y;
return temp;
}
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
}
//调用如下：
Point po1 = new Point(1, 1);
Point po2 = new Point(3, 4);
Point po3 = po1 + po2;
Console.WriteLine("{0}, {1}", po3.x, po3.y);
C# 不能重载的：[ ] && || . ?: () =
在 C# 中，可以为一个类实现多个运算符的重载，包括新的运算符。但是，为了使这些运算符重载生效，必须确保它们被声明为 public 和 static。
之所以用 public，是为了确保这些运算符重载被其他类访问和调用。public 访问修饰符告诉编译器，这些运算符可以从任何地方访问，而不仅仅是从类的内部访问。如果运算符不是 public，那么只能从类的内部访问，这会导致编译错误。
之所以用 static，是为了确保这些运算符重载生效。static 访问修饰符告诉编译器，这些运算符不是实例化的，而是类级别的运算符，可以在整个应用程序中使用。如果运算符不是 static，那么它们只能在类的内部使用，这会导致编译错误。
怎么理解呢？其实很简单，我们用的是 p1+p2，而不是类似 p1.+() 以及 p1.+ 这种错误形式。
很显然p1+p2这种写法，并不属于通常用点的方式进行链接式调用。
这种 p1+p2 的可行的前提，肯定是在程序运行之初就要支持的。
29、内部类和分部类
内部类：
调用：Person.Body.ShowBody();
ps：就是类中类，使得两个类的从属关系显示的更为亲密
class Person
{
public string name = "Default";
private Person[] friends;
public class Body{
public static void ShowBody(){
Console.WriteLine("ShowBody.");
}
}
}分部类：
关键词是 partial，把一个类分成几部分声明
属于不同的模块化子系统，然后不得不这样。
总之弹幕有人说这个很有用，先mark一下。
partial class Person{
public string name;
public int age;
}
partial class Person {
public string nation;
}30、继承
class PersonMan : Person {
public string nation;
}C#的继承：只能有唯一父类；C++的继承则可以有多个父亲；
所以有个梗，在C++中，可以有：class 吕布 : 丁原，董卓
31、里氏替换原则
任何父类出现的地方，子类都可以替代。优秀的设计应该是：用父类容器 装载子类对象。
eg：
Person p1 = new Student();
Person p2 = new Teacher();
eg：
GameObject[] objects = new GameObject[] { new Boss(), new Monster() ,\
new Player() };
遍历这个数组，可以用is和as来进行不同类型的对象的处理。 is和as：对象的类型检查与转换（服务于里氏替换原则）
is：(返回值是bool型)
eg： if (p is Player) ...
as: (返回值：转换成功时返回指定类型对象，转换失败时返回null)
eg: Player p = object as Player
常规操作——二者配合使用：
// 前置定义
class PersonMan : Person{
public int len;
}
class PersonWoman : Person{
public int dep;
}
Person p1 = new PersonMan() { name = "A", age = 18, len = 18 };
Person p2 = new PersonWoman();
if (p1 is PersonMan) { // 判断p1是否属于PersonMan类，如果是，则...
PersonWoman p3 = p2 as PersonWoman; // 令p2转换成PersonWoman类型
Console.WriteLine("Show:" + p3.name + " " + p3.dep);
}如果转换后的类型与目标类型相同，则转换成功。当Person有子类PersonMan时，一个PersonMan既是PersonMan，又是Person
32、继承中的构造函数
先调用父类构造，再调用子类构造
由于默认调用是父类的无参构造，约定父类的无参构造必须存在！（因为默认找无参构造）
如果想默认调用有参构造，需要用 base 关键字，这个时候允许没有声明父类无参构造
eg 伪代码：
class {
func() : this(可传参) // 去找对应参数的构造函数
func() : base(可传参) // 去找对应参数的父类构造函数
}
// 申明类和构造函数
class Father
{
public Father() { // 默认调用的无参父类构造函数
Console.WriteLine("Father NULL");
}
public Father(int i) {
Console.WriteLine("Father:" + i);
}
}
class Son : Father
{
public Son() { }
public Son(int i) : base(i) //base是Father()，base(i)是Father(i)
{
Console.WriteLine("Son: i");
}
public Son(int n, int m) : this(n) // this(..) 都是指自己的构造
{
Console.WriteLine("Son: n, m");
}
}
// 调用：
Son s = new Son(2, 3);
--控制台打印结果：
Father:2
Son: i
Son: n, m -解析：new Son(int, int) 的操作：1、先构造父类
2、再构造 this(int)
3、最后构造自己33、继承的构造调用关系
简言之，就是从老祖宗开始，逐步往各后代去调用
34、最基本的基类：object（引用类型）。
object对象由于是引用类型，他被设计成可以装任何种类对象的容器。
注意：object不能随便强转或者as，如：object w = (Son)f; 这种语法正确，但会出问题。
object val = 1.23f; // 装箱
Console.WriteLine(val);
float v = (float)val; // 拆箱引用类型：建议永远用as去转换，而不是强转：
object NewArray = new int[10];
int[] ar = NewArray; // 这句代码会报错，因为不能将object型隐式转换成int[]型
应该这么做：
object NewArray = new int[10];
int[] ar = NewArray as int[ ]
这里一个自己的小tip：
new和as的区别：new一定是用来分配内存的，而as是用来转换类型的
35、装箱拆箱（object操作的意义在哪？）
值类型用引用类型存储，保存地点可以由栈迁移到堆
好处：不确定类型时，可以方便参数先行存储和转换
缺点：内存迁移带来性能损耗
eg：object [ ] 可以在不知道成员是什么类型时暂时 “吃下一切”，可以用来装任何类型。
but，还是尽量少用，因为性能损耗和设计规范都有点问题。
36、密封类/密封函数，关键字：sealed
sealed类：让类无法再被继承（断子绝孙类，可以保证安全类和规范性）
sealed函数：该函数不能被override（不可被重写）
37、多态经典方案：
背景：我们试图解决一个问题：
class Father{
public void Speak() {
Console.WriteLine("Father");
}
}
class Son : Father{
public new void Speak()
{
Console.WriteLine("Son");
}
}当进行以下语句时，会有不同的表现：
Father s = new Son();
s.Speak(); // 执行Father的Speak函数，因为使用的是Father容器
(s as Son).Speak(); // 执行Son的Speak函数这对继承产生了一定的困扰，为了避免继承合逻辑，我们之后引入了 virtual, overide
virtual 虚函数：用来给子类重写的。
override：声明重写，然后补全这个函数的时候可以自动补全成带有一个base.Speak() 的子类重写函数。
class Father{
virtual public void Speak() {
Console.WriteLine("Father");
}
}
class Son : Father{
public override void Speak(){
base.Speak(); // base代表父类，可以用base保留父类的行为
}
}调用：
当我们再进行
s.Speak();
这个操作的时候，虽然s还在使用Father的容器，但是其Speak函数已经被override，所以会执行Son.speak() 方法
38、多态的另一种实现方法——抽象类：abstract修饰
一类class的统称，如：abstract class Things.
现实世界中不存在一类东西叫做：Things，但是我们可以把他们以后通过不同类继承出来。
这么做类似“蓝图”：
1、抽象类就只负责声明应该出现的具有共性的属性和方法，但不做具体实现
2、抽象类不可以被实例化
eg：
//抽象类
abstract class Father{
//抽象方法(只能写在抽象类里，且必须是public的，因为以后必须override)
public abstract void Speak(); // 不用写函数体，类似纯虚函数
}39、命名空间 namespace
namespace 具有以下特点：
1、像是工具包；相比之下 ，class像工具
2、可以分开写诶，像是之前那个分部类，可以写成好几段。
3、命名空间必须通过using引用或者点出使用，不然即使在同一个文件里一样会找不到。
4、可以嵌套:
namespace 工具包{
namespace 螺丝 { ... }
namespace 螺母 { ... }
}
引用时可以是：using 工具包.螺母；using Game.UI
5、namespace的类默认是internal（只能在程序集中使用），而不是private，要注意！
笔记还有部分适读性上的小毛病，目前赶着上新，待我有空一定来修！
友友们一起加油 owo