目录

• • • 1.语句块
    • 2.Write和WriteLine的区别：
    • 3.params
    • 4.托管代码和非托管代码
    • 5.DllImport的使用：
    • 6.WriteLine、ReadLine和ReadKey：
    • 7.C#中访问修饰符
    • 8.类型的实例化
    • 9.成员可以分为两种：数据成员和函数成员
    • 10.枚举enum和结构struct的区别：
    • 11.运行中的程序使用栈和堆来存储数据
    • 12.栈存储几种类型的数据：
    • 13.与栈不同，堆里的内存能够以任意顺序存入和移除.
    • 14.堆和栈：
    • 15.在声明一个类时使用static关键字，具有两个方面的意义：
    • 16.static在内存中的地址为：程序的全局数据区。
    • 17.值类型和引用类型
    • 18.C#的4种变量
    • 19.变量 、字段、属性的区别：
    • 20.常量字段const表现得像静态字段，但在内存中没有存储位置。
    • 21.析构函数执行在类的实例被销毁之前需要的清理或释放非托管资源的行为。
    • 22.非托管资源是指通过Win32 Api获得的文件句柄，或非托管内存块。
    • 23.const和readonly：
    • 24.this用法(指代当前实例、扩展方法、索引器)
    • • 1. this指代当前实例
      • 2. this用作扩展方法
      • 3. this用作索引器：
    • 25.派生类屏蔽基类的成员：
    • 26.virtual的使用
    • 27. 构造函数初始化语句：
    • 28.readonly字段
    • 29.本地变量与字段的区别：
    • 30.关键字var
    • 31.C#中方法的参数有四种类型
    • 32.值参数和引用参数：
    • 33.输出参数out
    • 34.成员访问修饰符：
    • 35.抽象类
    • 36.静态类
    • 37.C#提供隐式转换与显式转换
    • 38.运算符重载
    • 39.C# 关键字explicit和implicit
    • 40.typeof运算符
    • 41.结构和类的区别
    • 42.关于静态字段
    • 43.**可以声明为static的类成员类型(重要)**
    • 44.枚举
    • 45.数组
    • 46.委托
    • • 1.delegate委托
      • 2.Action委托
      • 3.Func委托
      • 4.Predicate委托
      • 5.这几种委托的区别：
    • 47.匿名方法
    • 48.Lambda表达式
    • 49.一些代码编写规范
    • 50.事件
    • 51. 接口
    • 52.转换
    • • （1）装箱和拆箱
      • （2）is运算符(用来检测转换是否成功，不像as操作符那样直接转换)：
      • （3）as运算符：
    • 53.泛型
    • 54.c#中的“\r”和“\n”问题
    • 55.本地变量和字段是否会自动初始化？
    • 56.属性相比公共字段的优点：
    • 57.枚举器和迭代器
    • 58.LINQ
    • 59.异步编程
    • 60.异常
    • 61.预处理指令
    • 62.反射和特性
    • 63.字符串
    • 64.List < T >
    • 65.方法重载和重写的区别
    • 66.简述c#中类(class)和结构(struct)的异同
    • 67.简述c#中接口和类的异同
    • 68. 一道C#编程测验题
    • 69.C#中如何判断传入值的数据类型
    • 70.C#中唯一的非派生类是Object类
    • 71.C#转义字符的两种处理方式
    • 72.抽象成员，哪些成员可以声明为抽象的，虚成员和抽象成员的区别
    • 73.构造函数重载、静态构造函数、构造函数分别什么时候执行？
    • 74.测验题：委托的创建和初始化
    • 75.测验题：判断类型是否是隐式转换
    • 76.LINQ的部分知识点考察
    • 77.哪些成员可以在接口内声明，列举接口和抽象类的区别？
    • 78.什么叫显式转换，什么叫隐式转换？装箱和拆箱又是什么？
    • 79.进程和线程分别是什么？谈谈进程和线程的区别与联系。
    • 80.一道c#试题
    • 81.使用CancellationTokenSource 取消多线程
    • 82.C#中的单例模式与IOC
    • 83.C# string.Join的用法
    • 84.C#中using
    • • 1.using指令
      • 2.using别名
      • 3.using语句
    • 85.object.ReferenceEquals方法
    • 86.读取环境变量
    • 87.C#新语法：顶级语句（C#9.0）
    • 88.C#新语法：全局Using指令（C#10.0）
    • 89.C#新语法:record类型（C#9.0）
    • 90.C#新语法:init（C#9.0）
    • 91.Sealed关键字
    • • 1.sealed关键字修饰类
      • 2.sealed关键字修饰方法或属性
    • 92.异步编程中Task.Run 和 Task.Factory.StartNew 区别
    • 93.C#中依赖注入的三种方式
    • • 1.通过接口注入
      • 2.通过属性访问器Settter注入
      • 3.通过构造函数注入
    • 94.C#中yield关键字使用：yield return和yield break的作用
    • 95.C#中的克隆
    • 96.Lazy（延迟初始化）的用法
    • • 1.Lazy简介
      • 2.应用场景
      • 3.Lazy基本用法
      • • 用法1：构造时使用默认的初始化方式
        • 用法2：构造时使用指定的委托初始化
    • 97.字典：Dictionary
    • • 1.何时使用Dictionary而不是List
      • 2.关于使用Dictionary时的注意事项
      • 3.Dictionary的一些简单用法
    • 98.字典：ConcurrentDictionary的使用
    • 99.TaskCompletionSource的使用
    • • 1.TaskCompletionSource简介以及简单使用方法
      • 2.TaskCompletionSource 的 TrySetResult 是线程安全
    • 100. IEnumerable接口与yield return
    • 101.反射和特性
    • • 1.反射
      • 2.特性
      • 3.反射和特性配合使用
    • 102.属性和字段的区别？为什么要用属性？
    • 103.事件Event的使用、与委托的区别
    • 104.关于C#中序列化的一些小问题
    • 105.C#中的文件操作
    • • 1.使用FileInfo查看文件属性
      • 2.使用DirectoryInfo查看文件夹属性
      • 3.使用File来读写文件
      • 4.使用FileStream来读写文件
      • 5.使用StreamReader和StreamWriter读写文本文件
    • 106.XML
    • 107.Json介绍
    • 108.StopWatch计时器
    • 109.Thread.Abort()和Thread.ResetAbort()
    • 110.字符串首字符大写的方法。
    • 111.使用下划线忽略使用的变量
    • 112.可空类型
    • 113.字符串的大量拼接使用 StringBuilder 代替
    • 114. 多线程禁止同时调用相同的方法
    • • 1.使用Lock锁定方法
      • 2.通过特性MethodImpl(不建议使用)
    • 115.C# Task.Run 和 Task.Factory.StartNew 区别
    • • 1.创建新线程
      • 2.等待线程
      • 3.长时间运行
    • 116.拼接 URI 路径
    • 117.将 int 输出为二进制字符串

  	2022.06，我正式走上了所追求、热爱的编程道路，用此文记录C#学习过程中的问题点。“书山有路勤为径，学海无涯苦作舟！”日后我也可以成为很厉害的技术大佬！

1.语句块

2.Write和WriteLine的区别：

（1）Write没有在字符串后面添加换行符，而WriteLine则在每个字符串后面添加了换行符。如图：

（2）从命令行读取和输入的例子：

using System;
using System.Text;
namespace APP
{class Program{static void Main(){Console.WriteLine("请输入您的姓名：");string name = Console.ReadLine();Console.WriteLine("请输入您的年龄：");int age =int.Parse(Console.ReadLine());//通过int.parse方法可以将字符串类型转化为int类型Console.WriteLine("您好，{0}岁的{1}", age, name);}}
}

3.params

params是一个计算机函数，表示函数的参数是可变个数的，即可变的方法参数，用于表示类型相同，但参数数量不确定。
C#开发语言中 params 是关键字，params主要的用处是在给函数传参数的时候用，就是当函数的参数不固定的时候。 在函数的参数数目可变而执行的代码差异很小的时候很有用！C#语法规定，params后边必定跟数组。作用是把不定数量的、同类型的参数装入这个数组中.

4.托管代码和非托管代码

（1）托管代码：
运行在CLR(CLR是一个通用语言架构，它定义了一个代码运行的环境）下的代码就是托管代码，诸如C#、VB.NET 写的代码都会先编译成MSIL（MS中间代码），并运行在CLR的子集CLI(Common Language Infrastructure）中，最终根据不同的平台使用JIT（just in Time）编译成机器代码。
与Java机制不同在于Java是经过一次编译和一次解释运行，C#是经过两次编译运行,这两个阶段分别为：源代码编译为托管代码，托管代码编译为微软平台的专用语言，又称机器语言。
（2）非托管代码：
非托管的代码也叫本地代码（native），是由操作系统管理的。
高级语言编写的程序必须经过一定的步骤编译为机器语言才能被机器理解和运行。
这一系列步骤为：预处理、编译、汇编、链接。
（3）托管代码和非托管代码的区别：
1、托管代码是一种中间语言，运行在CLR上；非托管代码被编译为机器码，运行在机器上。
2、托管代码独立于平台和语言，能更好的实现不同语言平台之间的兼容；非托管代码依赖于平台和语言。
3、托管代码可享受CLR提供的服务（如安全检测、垃圾回收等），不需要自己完成这些操作；非托管代码需要自己提供安全检测、垃圾回收等操作。

5.DllImport的使用：

托管代码生成的DLL文件，可以在VS中直接通过添加引用的方式使用。
非托管代码生成的DLL文件，比如使用C++编写的代码编译生成的DLL，不能在VS中直接引用，可以通过DllImport方法来使用。

6.WriteLine、ReadLine和ReadKey：

console.ReadLine()是等待输入，并按回车继续。
console.WriteLine()是向控制台窗口产生输出。
Console.ReadKey()是等待键盘输入，退出程序。使调试时能看到输出结果。如果没有此句，命令窗口会一闪而过。

7.C#中访问修饰符

在C#语言中，共有五种访问修饰符：public、private、protected、internal、protected internal。
（1）作用范围：

（2）在c#中，

1. 类、结构的默认修饰符是internal。
2. 类中所有的成员默认修饰符是private。
3. 接口默认修饰符是internal。
4. 接口的成员默认修饰符是public。
5. 命名空间、枚举类型成员默认修饰符是public。
6. 委托的默认修饰符是internal。

8.类型的实例化

从某一个类型模板创建实际的对象，就称为实例化该类型。

9.成员可以分为两种：数据成员和函数成员

数据成员：保存了这个类的对象或作为一个整体的类相关的数据；
函数成员：执行代码，函数成员定义类型的行为。

10.枚举enum和结构struct的区别：

enum与struct的区别是：枚举里的变量都是整型的同类型，而struct是由不同类型
的变量所组成的，默认情况下，枚举的第一个值为0，后面每个连续的元素值递增1。

11.运行中的程序使用栈和堆来存储数据

12.栈存储几种类型的数据：

某些类型变量的值；
程序当前的执行环境；
传递给方法的参数。

13.与栈不同，堆里的内存能够以任意顺序存入和移除.

14.堆和栈：

栈是一个内存数组，是一个LIFO（Last-In First-Out，后进先出）的数据结构。
堆和栈的区别主要有五大点，分别是：
（1）申请方式的不同。栈由系统自动分配，而堆是人为申请开辟;
（2）申请大小的不同。栈获得的空间较小，而堆获得的空间较大;
（3）申请效率的不同。栈由系统自动分配，速度较快，而堆一般速度比较慢;
（4）存储内容的不同。栈在函数调用时，函数调用语句的下一条可执行语句的地址第一个进栈，然后函数的各个参数进栈，其中静态变量是不入栈的。而堆一般是在头部用一个字节存放堆的大小，堆中的具体内容是人为安排;
（5）底层不同。栈是连续的空间，而堆是不连续的空间。

15.在声明一个类时使用static关键字，具有两个方面的意义：

防止程序员写代码来实例化该静态类；
防止在类的内部声明任何实例字段或方法。

16.static在内存中的地址为：程序的全局数据区。

17.值类型和引用类型

数据项的类型定义了存储数据需要的内存大小及组成该类型的数据成员。类型还决定了对象在内存中的存储位置——栈或堆。
类型被分为两种：值类型和引用类型，这两种类型的对象在内存中的存储方式不同。
值类型只需要一段单独的内存，用于存储实际的数据。
引用类型需要两段内存，第一段存储实际的数据，它总是位于堆中；第二段是一个引用，指向数据在堆中的存放位置。
对于值类型，数据存放在栈里；对于引用类型，实际数据存放在堆里而引用存放在栈里。

18.C#的4种变量

分别是本地变量、字段、参数、数组元素。
本地变量：在方法的作用域保存临时数据，不是类型的成员。
字段：保存和类型或类型实例相关的数据，是类型的成员。
参数：用于从一个方法到另一个方法传递数据的临时变量，不是类型的成员。
数组元素：（通常是）同类数据项构成的有序集合的一个成员，可以为本地变量，也可以为类型的成员。
###简单的变量声明
一个简单的变量声明至少需要一个类型和一个名称，如int a,其中int为类型，a为名称。

19.变量 、字段、属性的区别：

一句话：字段、属性都是变量，只是为了区分和数据安全设置的。
字段的使用场景：与类或者对象关系密切，建议使用private修饰。
属性的使用场景：对字段进行封装，提供get/set关键字，进行访问。
变量的使用场景：与类或者对象关系不密切，常常在方法或者语句块中使用。
字段和属性是相对于类而言的，而变量相对于方法或者语句块而言，可以在任何地方使用。

20.常量字段const表现得像静态字段，但在内存中没有存储位置。

虽然常量成员表现得像一个静态量，但不能将常量声明为静态static，如：static const int a=3.14这句语法是错误的。

21.析构函数执行在类的实例被销毁之前需要的清理或释放非托管资源的行为。

22.非托管资源是指通过Win32 Api获得的文件句柄，或非托管内存块。

23.const和readonly：

const是静态常量，readonly是动态常量。
静态常量是指编译器在编译时候会对常量进行解析，并将常量的值替换成初始化的那个值；而动态常量的值则是在运行的那一刻才获得的，编译器编译期间将其标示为只读常量，而不用常量的值代替，这样动态常量不必在声明的时候就初始化，而可以延迟到构造函数中初始化。
区别：可以通过静态常量与动态常量的特性来说明：
1）const修饰的常量在声明的时候必须初始化;readonly修饰的常量则可以延迟到构造函数初始化 。
2）const修饰的常量在编译期间就被解析，即常量值被替换成初始化的值;readonly修饰的常量则延迟到运行的时候。
此外const常量既可以声明在类中也可以在函数体内，但是static readonly常量只能声明在类中。

24.this用法(指代当前实例、扩展方法、索引器)

1. this指代当前实例

this关键字在类中使用，是对当前实例的引用，它只能被用在下列类成员的代码块中：
（1）实例构造函数；
（2）实例方法；
（3）属性和索引器的实例访问器。
值得注意的是，静态成员并不是实例的一部分，所以不能在任何静态函数成员的代码中使用this关键字，确切来说，this用于下列目的：
用于区分类的成员和本地变量或参数；
作为调用方法的实参。

2. this用作扩展方法

扩展方法能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。扩展方法是一种特殊的静态方法，但可以像扩展类型上的实例方法一样进行调用。C#扩展方法第一个参数指定该方法作用于哪个类型，并且该参数以 this 修饰符为前缀。
需要注意的几点：
（1）扩展方法（this 需要扩展的类 命名），如：public static void ExtensionEat(this Person person)；
（2）扩展方法必须是静态类的一个静态方法。
（3）调用扩展方法,必须用对象来调用 。
如图看一段代码：

using System;
namespace ConsoleApp10
{class Program{static void Main(string[] args){Music p = new Music();p.ExtensionEat();p.ExtensionHello();p.ExtensionHaHa();ExtensionMusic.ExtensionHaHa(p);Console.ReadLine();}}public class Music{public void Eat(){Console.WriteLine("听歌曲");}public void Hello(string name){Console.WriteLine("歌曲名：" + name);}}public static class ExtensionMusic //静态的扩展类，用于扩展Music类{public static void ExtensionEat(this Music  mu)//扩展方法必须是静态类的一个静态方法,this Music  mu这一句表示该ExtensionEat要扩展的类名是Music,然后在Music的实例中就可以调用该方法{mu.Eat();Console.WriteLine("打开播放器");}public static void ExtensionHello(this Music mu){mu.Hello("起风了");Console.WriteLine("真好听");}public static void ExtensionHaHa(this Music mu){Console.WriteLine("多听几遍");}}
}

运行结果：

3. this用作索引器：

索引器（Indexer） 允许一个对象可以像数组一样使用下标的方式来访问。
先看一段代码：

/// 

/// 最简单的索引器
/// 
public class IDXer
{private string[] name = new string[10];//索引器必须以this关键字定义，其实这个this就是类实例化之后的对象public string this[int index]{get{return name[index];}set{name[index] = value;}}
}public class Program
{static void Main(string[] args){//最简单索引器的使用           IDXer indexer = new IDXer();//“=”号右边对索引器赋值，其实就是调用其set方法indexer[0] = "张三";indexer[1] = "李四";//输出索引器的值，其实就是调用其get方法Console.WriteLine(indexer[0]);Console.WriteLine(indexer[1]);Console.ReadKey();}
}

 //以字符串为下标的索引器public class IDXer2{private Hashtable name = new Hashtable();//以字符串为下标的索引器public string this[string index]{get{return name[index].ToString();}set{name.Add(index, value);}} }public class Program{static void Main(string[] args){//以字符串为下标的索引器IDXer2 indexer2 = new IDXer2();indexer2["A01"] = "张三";indexer2["A02"] = "李四";Console.WriteLine(indexer2["A01"]);Console.WriteLine(indexer2["A02"]);Console.ReadKey();}}

索引器的索引值（Index）类型不限定为整数，如上两个图代码中的整形和字符串型索引。
索引器与属性的区别：
（1）索引器的命名只能为this，而属性可以任意命名（开头字母大写）；
（2）索引器可以重载，属性不可以；
（3）索引器不可用static进行声明，属性可以。

25.派生类屏蔽基类的成员：

虽然派生类不能删除它继承的任何成员，但可以用与基类成员名称相同的成员来屏蔽基类成员，这也是继承的主要功能之一，很实用。派生类屏蔽基类成员的关键字是new，在派生类中屏蔽一些基类成员的一些要点如下：
（1）要屏蔽一个继承的数据成员，需要声明一个新的相同类型的成员，并使用相同的名称。
（2）通过在派生类中声明新的带有相同签名的函数成员，可以隐藏或屏蔽继承的基类的函数成员。注意：签名由名称和参数列表组成，不包括返回类型。
（3）要让编译器知道你在故意屏蔽继承的成员，实用new修饰符。否则，程序会成功编译，但会警告你隐藏了一个继承的成员。
（4）也可以屏蔽静态成员。

26.virtual的使用

当使用基类引用访问派生类对象时，得到的是基类的成员。虚方法可以使基类的引用访问“升至”派生类级别。可以使用基类引用调用派生类的方法，只需要满足以下条件：
（1）派生类的方法和基类的方法拥有相同的签名和返回类型；
（2）基类的方法使用virtual标注；
（3）派生类的方法使用override标注。
可对比以下两图：

27. 构造函数初始化语句：

如，一个简单的继承类程序：

using System;
namespace Application
{public class ShangPin{private double _price;private double _count;private string _name;private int _id;public double Price{get { return _price; }set { _price = value; }}public double Count{get { return _count; }set { _count = value; }}public string Name{get { return _name; }set { _name = value; }}public int ID{get { return _id; }set { _id = value; }}public ShangPin(string name, double price, int id, double count){this.Name = name;this.Price = price;this.ID = id;this.Count = count;Console.WriteLine("名称：{0},价格：{1},编号：{2},数量：{3}", this.Name, this.Price, this.ID, this.Count);}}public class Banana : ShangPin{private double _keepDays;public double KeepDays{set { _keepDays = value; }get { return _keepDays; }}public Banana(string name, double price, int id, double count, double keepDays) : base(name, price, id, count){this.KeepDays = keepDays;}}class app{static void Main(){// ShangPin shangPin = new ShangPin("可乐",2.5,1,100);// Console.WriteLine("名称：{0},价格：{1},编号：{2},数量：{3}",shangPin.Name,shangPin.Price,shangPin.ID,shangPin.Count );Banana banana = new Banana("香蕉", 2.3, 2, 50.0, 7);Console.WriteLine("名称：{0},价格：{1},编号：{2},数量：{3},保存天数：{4}", banana.Name, banana.Price, banana.ID, banana.Count, banana.KeepDays);//会先调用基类的构造函数，然后再调用子类的构造函数}}}

运行结果：

而另外一种形式的构造函数初始化语句（通过this）可以让编译器使用该类中的其他构造函数。

28.readonly字段

readonly字段只可以在构造函数中初始化，如果在其他方法中初始化一个readonly字段（即使这个方法只被构造函数调用），会得到一个编译错误。

29.本地变量与字段的区别：

30.关键字var

编译器可以通过初始化语句提供的信息推断出数据类型。
（1）传统定义变量是已经知道变量的类型，如： int a = 1； string b = “hello”；char c=‘x’;
而var关键字不用预先知道变量的类型，是根据给变量赋值来判定变量属于什么类型；如var a =1， 则a是整型；var b = “hello”,则b是字符型;var c=‘x’,则c也是字符型。
（2）简言之，var可以代替任何类型，编辑器会根据上下文来判断使用者具体想用什么类型，当无法确定自己将使用什么类型时，就可以使用var。
（3）使用var关键字有一些重要的条件：

1. 必须在定义时初始化。必须是var a=“abc”的形式，不能是var a； a=“abc”的形式；
2. 只能用于本地变量，不能用于字段；
3. 只能在变量声明中包含初始化时使用；
4. 一旦编译器推断除变量的类型，它就是固定且不能更改的。

31.C#中方法的参数有四种类型

  （1） 值参数  (不加任何修饰符,是默认的类型)（2）引用型参数  (以ref 修饰符声明)（3）输出参数  (以out 修饰符声明)（4）数组型参数  (以params 修饰符声明)

32.值参数和引用参数：

当值参数为值类型时，值被复制，产生一个独立的数据项，当值参数为引用类型时，引用被复制，实参和形参都引用堆中的同一个对象。
使用引用参数时，必须在方法的声明和调用中都使用ref修饰符。
引用类型作为值参数和引用参数：
（1）将引用类型对象作为值参数传递 ：如果在方法内创建一个新对象并赋值给形参，将切断形参与实参之间的关联，并且在方法调用结束之后，新对象也将不复存在。
（2）将引用类型作为引用参数传递 ：如果在方法内创建一个新对象并赋值给形参，在方法结束后该对象依然存在，并且是实参所引用的值。

33.输出参数out

引用参数ref修饰的参数必须对其赋初值，但是初值不能是常量（即不能用const修饰），因为按引用传递可能会改变参数的值。在函数使用out参数时，必须看做是尚未赋值（不晓得为什么），实参传递给形参的值在函数执行时会丢失，参考以下代码段：

34.成员访问修饰符：

35.抽象类

抽象类是指设计为被继承的类，抽象类只能被用作其他类的基类。
（1）不能创建抽象类的实例；
（2）抽象类必须使用abstract修饰符来声明，如下图：

（3）抽象类可以包含抽象成员和普通的非抽象成员，即抽象类的成员可以是抽象成员和普通成员的任意组合。
（4）抽象类自己可以派生另外一个抽象类，如下图：

（5）任何派生自抽象类的类必须使用override关键字实现该类的所有抽象成员，除非派生类自己也是抽象类。
看一段代码:

36.静态类

静态类中所有的成员都是静态的，静态类用于存放不受实例数据影响的函数或数据。静态类的一个常见用途就是创建一个包含一组数学方法和值的数学库。
关于静态类需要注意的几个地方：
（1）类本身必须被标记为static;
（2）类的所有成员必须是静态的；
（3）类可以有一个静态构造函数，但不能有实例构造函数，不能创建该类的实例；
（4）静态类是隐式封装的，也就是说，不能继承静态类。

37.C#提供隐式转换与显式转换

对于隐式转换，当决定在特定上下文中使用特定类型时，如有必要，编译器会自动执行转换；
对于显式转换，编译器只在使用显示转换运算符时才执行转换。

38.运算符重载

运算符重载：通过特定的语法，使某些运算符可以具备特殊的功能。关键字operator，修饰符必须为public static。
运算符重载的例子：

using System;public struct Point
{public double x;public double y;public Point(double x,double y){this.x = x;this.y = y;}
//运算符重载，使加号具有新的功能
//可以实现两个Point对象直接相加，得到一个新的点public static Point operator +(Point p1,Point p2){return new Point(p1.x + p2.x, p1.y + p2.y);}//参数类型可以不相同public static Point operator + (Point p1,int a){return new Point(p1.x + a, p1.y + a);}
//*号是二元运算符，因此必须有两个参数public static Point operator *(Point p1,Point p2){return new Point(1, 1);}
//-号的身份有两种：1是加减乘除的减号，2是负号。为前者时是二元运算符，为后者是一元运算符。public static Point operator - (Point p1){return new Point(1, 1);}//【重载--运算符】练习public static Point operator --(Point p1){return new Point(p1.x-1,p1.y-1);}
}public class Program
{public static void Main(string[] args){Point p1 = new Point(1, 2);Point p2 = new Point(2, 3);Point p = p1 + p2;//【重载--运算符】练习Point p3 = new Point(1, 3);p3--;Console.WriteLine(p3.x);Console.WriteLine(p3.x);Console.WriteLine(p3.y);p3 = new Point(1, 3);--p3;Console.WriteLine(p3.x);Console.WriteLine(p3.y);}
}

39.C# 关键字explicit和implicit

implicit：代表用来声明隐式自定义类型的转换;
explicit：代表用来声明显示自定义类型的转换。

40.typeof运算符

typeof用于获取类型的 System.Type 对象
例如下面代码：

using System.Reflection;//反射
using System;
namespace APP
{class SomeClass{public int Field1;public int Field2;public void Method1(){}public int Method2(){ return 1;}}class Program{static void Main(){var t = typeof(SomeClass);FieldInfo[] fi = t.GetFields(); //返回FieldInfo类型，用于取得该类的字段（成员变量）的信息MethodInfo[] mi = t.GetMethods();//返回MethodInfo类型，用于取得该类的方法的信息foreach (var f in fi){Console.WriteLine("Field:{0}", f.Name);}foreach (var m in mi){Console.WriteLine("Method:{0}", m.Name);}       }}
}

41.结构和类的区别

结构和类非常相似，都有数据成员和函数成员，最重要的区别是：
（1）类是引用类型，而结构是值类型；
（2）结构是隐式封装的，这意味着他们不能被派生。
结构也可以有实例构造函数和静态构造函数，但不能有析构函数。

42.关于静态字段

static修饰的静态字段被类的所有实例共享，所有实例都访问同一内存位置。如果该内存位置的值被一个实例改变了，这种变化对于所有的实例都改变。

43.可以声明为static的类成员类型(重要)

44.枚举

（1）枚举是一个值类型， 包含一组命名的常量， 枚举类型用 enum 关键字定义。如，声明一个简单的枚举类：

（2）默认情况下， enum 的类型是 int。
（3）动态获得枚举类型的信息：
Enum.GetNames：该方法返回一个包含所有枚举名的字符串数组，如下图：
Enum.GetValues：为了获得枚举的所有值， 可以使用 Enum.GetValues 。 Enum.GetValues 返回枚举值的一个数组。 为了获得整数值， 需要把它转换为枚举的底层类型， 为此应使用 foreach语句，如下图：

（4）Flags特性：没理解（后续学习）

45.数组

（1）C#不支持动态数组，也就是说，数组一旦被创建，大小就固定了。
（2）C#中的各种数组：

（3）数组中一些可用的方法和属性：

46.委托

自己以前写过的委托笔记
委托就是可以用方法名调用另一方法的便捷方法，可以理解为一个”命令”。
委托是一种用户自定义的类型，它也是引用类型，委托持有一个或者多个方法，以及一些列预定义操作。

1.delegate委托

先看一代码：

using System;namespace enumExample
{delegate void myDel(int value);//声明一个委托类型class Program{void PrintLow(int value){Console.WriteLine("{0}---Low Value", value);}void PrintHigh(int value){Console.WriteLine("{0}---High Value", value);}static void Main(string[] args){Program program = new Program();myDel del;//声明一个委托变量Random rand = new Random();//创建随机整数生成器对象int randValue = rand.Next(99);//该随机数在0到99之间随机选取del = randValue < 50 ? new myDel(program.PrintLow) : new myDel(program.PrintHigh);//当随机数的值小于50时，创建一个包含PrintLow的委托对象并将其赋值给del；//当随机数的值大于50时，创建一个包含PrintHigh的委托对象并将其赋值给del；del(randValue);//执行委托}}
}

运行结果：


因此使用委托的步骤：
（1）声明一个委托类型；

delegate void myDel(int value);//声明一个委托类型

（2）使用该委托类型声明一个委托变量；

myDel del;//声明一个委托变量

（3）创建委托类型的变量，把它赋值给委托变量。新的委托对象包含指向某个方法的引用，这个方法和第一步定义的签名和返回类型保持一致；

del = randValue < 50 ? new myDel(program.PrintLow) : new myDel(program.PrintHigh);//当随机数的值小于50时，创建一个包含PrintLow的委托对象并将其赋值给del；//当随机数的值大于50时，创建一个包含PrintHigh的委托对象并将其赋值给del；

（4）（非必要步骤）可以选择为委托对象增加其他方法（这些方法必须和第一步定义的签名和返回类型保持一致）；
（5）在代码中可以像调用方法一样调用委托，在调用委托的时候，其包含的每一个方法都会被执行。

 del(randValue);//执行委托

再看一段代码，稳固下委托的使用步骤：

using System;namespace ConsoleApp1
{class Program{public delegate void MyDelete(string str);//声明一个委托，可以简单地把委托理解为一个”命令”static void Print1(string str)//定义一个方法Print1{Console.WriteLine("Print1:"+str);}static void Print2(string str)//定义一个方法Print2{Console.WriteLine("Print2:" + str);}static void Main(){MyDelete myDelete=Print1; //将方法追加至委托myDelete += Print2;//委托的多播；myDelete("hello");//该myDelete委托此时调用的是Print1和Print2两个函数，这就是委托的多播（一个委托可以调用多个方法）Console.ReadLine();}}
}

运行结果：

调用带有返回值的委托：

如：

using System;
namespace ConsoleApp1
{delegate int MyDel();//声明一个返回值为int的委托类型class MyClass{private int _value = 5;public int Add3(){_value += 3;return _value;}public int Add2(){_value += 2;return _value;}}class Program{static void Main(){MyClass mc = new MyClass();MyDel del1=mc.Add2;//给该委托加一个方法del1 += mc.Add3;//给该委托追加一个方法del1 += mc.Add2;//给该委托追加一个方法Console.WriteLine("Value:{0}", del1());}}
}

运行结果：

调用带有引用参数的委托：

2.Action委托

Action委托签名不提供返回类型（也就是说Action委托是没有返回值的），它具有Action、Action、Action……Action多达16个的重载，其中传入参数均采用泛型中的类型参数T，涵盖了几乎所有可能存在的无返回值的委托类型。
代码示例：

 class Program{public void Print(){Console.WriteLine("我是一个普通的输出方法");}public void Add1(int a, int b){Console.WriteLine("a+b的值为{0}", a + b);}public void Add2(string name, int age){Console.WriteLine("我的名字叫：{0}，今年{1}岁", name, age);}public void Add3(bool isTrue,string str){if (isTrue){Console.WriteLine("Yes,"+str);}else{Console.WriteLine("No," + str);}}public static void Main(string[] args){Program program = new Program();Action ac1 = program.Print; // Action是系统内置（预定义）的一个委托类型，它可以指向一个没有返回值，没有参数的方法ac1();Action ac2 = program.Add1; // 定义了一个委托类型，这个类型可以指向一个没有返回值，有两个int参数的方法ac2(3, 4);Action ac3 = program.Add2; // Action可以后面通过泛型去指定Action指向的方法的多个参数的类型，参数的类型跟Action后面声明的委托类型是对应的ac3("张三", 23);Action ac4 = program.Add3;bool isTrue = false;ac4(isTrue, "你好");}}

3.Func委托

Func具有Func、Func、Func17种类型重载，T1……T16为出入参数，Tresult为返回类型。Func委托必须有返回值

 class Program{private  int Test(){return 1;}private  int Mes(string name){Console.WriteLine("我的名字叫：" + name);return 100;}private  int Add(int a, int b){return a + b;}public static void Main(string[] args){Program program = new Program();Func fu1 = program.Test; // Func中的泛型类型指定的是方法的返回值类型int res1 = fu1();Console.WriteLine(res1);Func fu2 = program.Mes; // Func后面可以跟很多类型，最后一个类型是返回值类型，前面的类型是参数类型，参数类型必须跟指向的方法的参数类型安装顺序对应int res2 = fu2("李四");Console.WriteLine(res2);Func fu3 = program.Add; // Func后面必须指定一个返回值类型，参数类型可以有0~16个，先写参数类型，最后一个是返回值类型int res3 = fu3(2, 3);Console.WriteLine(res3);}}

4.Predicate委托

• Predicate是返回bool型的泛型委托；
• Predicate表示传入参数为int，返回bool的委托；
• Predicate有且只有一个参数，返回值固定为bool；

 class Program{private bool isEqual(bool b){return b;}private bool Show(int number){if (number == 1){return true;}else{return false;}}public static void Main(string[] args){Program program = new Program();Predicate p1 = program.Show;// Predicate是返回bool型的泛型委托，有且只有一个参数bool res1= p1(5);Console.WriteLine(res1);Predicate pre = program.isEqual; // Predicate是返回bool型的泛型委托，有且只有一个参数bool res2= pre(2 > 1);Console.WriteLine(res2);}}

5.这几种委托的区别：

• Delegate至少0个参数，至多32个参数，可以无返回值，也可以指定返回值类型；
• Func可以接受0个至16个传入参数，必须具有返回值；
• Action可以接受0个至16个传入参数，无返回值；
• Predicate只能接受一个传入参数，返回值为bool类型；

47.匿名方法

匿名方法是在初始化委托时内联（inline）声明的方法。

48.Lambda表达式

Lambda表达式的出现很好地替代了匿名语法，它是匿名方法的简写形式,用来代替匿名方法。

49.一些代码编写规范

（1）类名使用 BigCamelCase 大驼峰风格：
如：BaseClass,DerivedClass,SecondDerivedClass。
（2）方法名也用BigCamelCase大驼峰风格：
如：GetHttpMessage()，GetValue()。
（3）参数名、成员变量、局部变量都统一使用 lowerCamelCase 小驼峰风格：
如：localValue,inputUserId。
（4）常量命名全部大写，单词间用下划线隔开，力求语义表达完整清楚，不要嫌名字长：
如：MAX_STOCK_COUNT,CACHE_EXPIRED_TIME。
（5）抽象类命名使用 Abstract开头 或 Base 结尾 ；异常类命名使用 Exception 结尾：
抽象类是特殊类，不能被实例化，抽象方法只能存在于抽象类中
访问修饰符 abstract class 类名
{
访问修饰符 abstract void 方法名();
}
抽象方法是一种特殊虚方法，只能声明，不能实现；
（6）测试类命名以它要测试的类的名称开始，以 Test 结尾。
（7）接口和实现类的命名：接口以I开头，实现类用 Impl 结尾：
如：XOrderImpl 实现 IOrder 接口。
（8）枚举类名带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开：
如：枚举名字为 ProcessStatusEnum 的成员名称：SUCCESS / UNKNOWN_REASON。

50.事件

（1）使用 += 运算符注册事件；使用 -= 运算符取消订阅。
（2）C# 中使用事件机制实现线程间的通信。
（3）事件模型的5个组成部分
事件拥有者（event source）（类对象）（有些书将其称为事件发布者）；
事件成员（event）（事件拥有者的成员）（事件成员就是事件本身，事件不会主动发生，其只会在事件拥有者的内部逻辑的触发下发生。）；
事件响应者（event subscriber）（类对象）（有些书将其称为事件订阅者）；
事件处理器（event handler）（事件的响应者的成员）（根据拿到的事件参数/信息对事件进行处理）；
事件订阅（委托类型）。
例如，“裁判员开枪，运动员开始跑步。”
在上面这个例子中，事件拥有者是裁判员，事件成员是开枪，事件响应者是运动员，事件处理是开始跑步。
（4）代码举例：

	//事件的使用
//1.声明一个委托
//2.声明一个事件
//3.编写引发事件的函数
//4.编写引发事件后的处理程序
//5.把事件发生后的处理程序注册到事件上
using System;
namespace APP
{//事件发送者class Dog{//1.声明关于事件的委托；public delegate void AlarmEventHandler(object sender, EventArgs e);//2.声明事件；   public event AlarmEventHandler Alarm;//3.编写引发事件的函数；public void OnAlarm(){if (this.Alarm != null){Console.WriteLine("\n狗报警: 有小偷进来了,汪汪~~~~~~~");this.Alarm(this, new EventArgs());   //发出警报}}}//事件接收者class Host{//４.编写事件处理程序void HostHandleAlarm(object sender, EventArgs e){Console.WriteLine("主人: 抓住了小偷！");}//５.注册事件处理程序public Host(Dog dog){dog.Alarm += new Dog.AlarmEventHandler(HostHandleAlarm);}}//６.现在来触发事件class Program{static void Main(string[] args){Dog dog = new Dog();Host host = new Host(dog);//当前时间，从2008年12月31日23:59:50开始计时DateTime now = new DateTime(2015, 12, 31, 23, 59, 50);DateTime midnight = new DateTime(2016, 1, 1, 0, 0, 0);//等待午夜的到来Console.WriteLine("时间一秒一秒地流逝... ");while (now < midnight){Console.WriteLine("当前时间: " + now);System.Threading.Thread.Sleep(1000);    //程序暂停一秒now = now.AddSeconds(1);                //时间增加一秒}//午夜零点小偷到达,看门狗引发Alarm事件Console.WriteLine("\n月黑风高的午夜: " + now);Console.WriteLine("小偷悄悄地摸进了主人的屋内... ");dog.OnAlarm();//引发事件的函数Console.ReadLine();}}
}

（5）再如代码举例:

	//事件的使用
//1.声明一个委托
//2.声明一个事件
//3.编写引发事件的函数
//4.编写引发事件后的处理程序
//5.把事件发生后的处理程序注册到事件上
using System;
namespace APP
{public class Dog{public delegate void dele();//1.声明一个委托public event dele deleHandler;//2.声明一个事件public void cry()//3.引发事件的函数{Console.WriteLine("小偷进来，狗开始叫：");if (deleHandler != null){deleHandler();//引发该事件}}}public class Program{public static void result()//4.事件发生后的处理程序{Console.WriteLine("狗叫之后，主任转身起床抓小偷!");}static void Main(){Dog dog = new Dog();dog.deleHandler += result;//5.把事件发生后的处理程序注册到事件上dog.cry(); //引发事件的发生  }}
}

51. 接口

（1）接口的声明不能包含以下成员：
数据成员、静态成员。
接口的声明只能包含如下类型的非静态成员函数的声明：
方法、属性、事件、索引器。
（2）这些函数成员的声明不能包含任何实现代码，在每一个成员声明的主体后必须使用分号；
（3）接口名称必须从大写的I开始写起；
（4）下面声明一个简单的接口：

 public interface IMyinterFace1{int add(int low, int high);double reduce(double low, double high);}

（5）接口的访问性和接口成员的访问性之间有一些区别：
接口的声明可以有任何的访问修饰符（但一般都为public），如：private、protected、internal、public。而接口的成员是隐式public的，不能有任何的访问修饰符，包括public。例如下面的这段代码：

 public interface IMyinterFace1{//接口成员不允许有访问修饰符int add(int low, int high);//正确double reduce(double low, double high);//正确public int add_1(int low, int high);//错误private double reduce_2(double low, double high);//错误}

（6）只有类和接口才能实现接口，然而要实现接口，类和结构必须：在基类列表中包含接口名称，为每一个接口的成员提供实现。
注意：如果类实现了接口，它就必须实现类的所有成员；
如果类从基类继承并实现了接口，则基类列表中的基类名称必须放在所有接口之前，例如下图：

比较接口和抽象类：
抽象类可以有
（7）as运算符和接口一起配合使用是很好的选择。
如果我们尝试将类对象的引用强制转换为类未实现的接口的引用，强制转换操作会抛出一个异常，可以通过使用as运算符来避免这个问题。具体如下：
如果类实现了接口，表达式指向返回接口的引用。
如果类没有实现接口，表达式返回null而不是异常。

if(this !=null)判空的目的是看看接口是否拿到了类的实例。

（8）类或结构可以实现任意数量的接口。
（9）如果一个类实现了多个接口，并且其中一些接口具有相同的签名和返回类型的成员，那么类可以实现单个成员来满足所有包含重复成员的接口。例如：

using System;
namespace APP
{interface IMyinterFace1{void PrintOut(string s);}interface IMyinterFace2{void PrintOut(string t);}public class AP : IMyinterFace1,IMyinterFace2{public void PrintOut(string s){Console.WriteLine(s);}}public class A{static void Main(){AP aP = new AP();aP.PrintOut("你好世界！");}}
}

（10）接口还可以继承接口，例如：

  interface IMyinterFace1{void PrintOut(string s);}interface IMyinterFace2{void PrintOut(string t);}interface IMyinterFace3 : IMyinterFace1, IMyinterFace2{}

(11)接口隔离原则：在实际项目中，可以实现一些小接口，而不是把功能都集中在一个大接口里。

52.转换

转换是接收一个类型的值并使用它作为另一个类型的等价值的过程。
使用强制转换表达式，意味着可能要承担数据丢失的后果。

（1）装箱和拆箱

• 装箱：将值类型转换为引用类型的操作。
• 拆箱：相应地将引用类型转换成值类型。
  

（2）is运算符(用来检测转换是否成功，不像as操作符那样直接转换)：

有时候有些转换是不成功的，需要在运行时抛出一个InvalidCastException异常，可以使用is运算符来检查转换是否会成功完成，从而避免盲目尝试转换。
is运算符的语法如下：

源表达式 is 目标类型

如果源表达式可以通过以下三种方式：引用、拆箱、装箱转换成功，则运算符返回true。
代码举例：

using System;
namespace APP
{public class Person{public string Name = "小明";public int Age = 25;}public class Employee : Person{}public class Program{static void Main(){Employee bill = new Employee();Person p;if(bill is Person)//检测变量bill能否转换为Person类型{p = bill;Console.WriteLine("Person Info:{0},{1}", p.Name, p.Age);}}}
}

注意： is运算符只可用于引用、装箱、拆箱三种转换，不可用于用户自定义转换。

（3）as运算符：

as运算符和强制转换运算符类似，只是不抛出异常。如果转换失败，它返回空而不是抛出异常。
语法如下：
源表达式 as 目标类型
注意： 目标类型必须是引用类型。

（6）当长类型的数据转换成短数据时，数据可能会丢失，需要我们进行显示地强制转换。

53.泛型

泛型：多种类型可以共享一组代码。泛型允许我们声明类型参数化的代码，可以用不同的类型进行实例化，也就是说，我们可以用“类型占位符”来写代码，然后在创建类的实例时指明真实的类型。
（1）C#提供了5中泛型，包括：类、结构、接口、委托和方法。（注意：前四种是方法，而方法则是成员。）
（2）泛型类不是实际的类，而是类的模板，也就是说，我们要先从他们构建实际的类类型，然后创建这个构建后的类类型的实例。这个过程如图：

（3）泛型类代码
看一段代码：

using System;
namespace APP
{public class GeneriClass1 //泛型类GeneriClass1{private T[] arr;public GeneriClass1(int size)//构造函数{arr = new T[size];}public T GetItem(int index){T t = arr[index];return t;}public void setItem(T t,int index){arr[index] = t;}}public class Program{static void Main(){GeneriClass1 IntArray = new GeneriClass1(5);//构建实际的类类型，然后创建这个构建后的类类型的实例GeneriClass1 StringArray = new GeneriClass1(5);//构建实际的类类型，然后创建这个构建后的类类型的实例for (int i = 0; i < 5; i++){IntArray.setItem(i * 5, i);}for (int i = 0; i < 5; i++){Console.Write(IntArray.GetItem(i)+" ");}Console.WriteLine();StringArray.setItem("老鼠", 0);StringArray.setItem("小狗", 1);StringArray.setItem("乌龟", 2);StringArray.setItem("小西八", 3);StringArray.setItem("小八嘎", 4);for (int i = 0; i < 5; i++){Console.Write(StringArray.GetItem(i)+" ");}Console.WriteLine();}}
}

（4）泛型方法：
泛型方法具有类型参数列表和可选的约束。

1. 泛型方法有两个参数列表：
   封闭在圆括号内的方法参数列表和封闭在尖括号内的类型参数列表。
2. 要声明泛型方法，需要：在方法名称之后和方法参数列表之前防止类型参数列表，并在方法参数列表后放置可选的约束子句。
   如图：
   
3. 泛型方法的调用：
   
4. 泛型方法举例：
   代码：

using System;
namespace APP
{class Simple//非泛型类{public static void ReversePrint(T[] arr)//泛型方法{Array.Reverse(arr);//翻转该数组foreach( T item in arr){Console.Write(item.ToString()+" ");}Console.WriteLine();}}class Program{static void Main(){var intArray = new int[5] { 1,3,5,7,9};var stringArray = new string[5] { "s1","s2","s3","s4","s5"};var doubleArray = new double[5] { 1.2,2.3,3.4,4.5,5.6};Simple.ReversePrint(intArray);//调用方法Simple.ReversePrint(intArray);//推断类型并调用Simple.ReversePrint(stringArray);//调用方法Simple.ReversePrint(stringArray);//推断类型并调用Simple.ReversePrint(doubleArray);//调用方法Simple.ReversePrint(doubleArray);//推断类型并调用}}
}

（5）扩展方法和泛型类：
扩展方法可以和泛型类结合来使用，它允许我们将类中的静态方法关联到不同的泛型类上，还允许我们像调用类构造实例的实例方法一样来调用方法。

代码举例：

using System;
using System.Collections.Generic;namespace APP
{public class Holder{List list = new List();public Holder(T t1,T t2,T t3){list.Add(t1);list.Add(t2);list.Add(t3);}public List returnList(){return list;}}public static class ExtendExample//泛型类的扩展方法必须是静态static的{public static void ExtendH(this Holder e,int index1,string s1)//扩展方法  注意：扩展方法的定义必须要有this,this后边跟的是扩展的泛型类的名字.此ExtendH方法有两个形参，分别是int型的index1，string型的s1{List lists = new List();lists = e.returnList();Console.WriteLine(index1+" "+s1);foreach(var item in lists){Console.Write(item+" ");}Console.WriteLine();}}public class Program{public static void Main(){Holder intHolder = new Holder(1, 3, 5);Holder stringHolder = new Holder("s1", "s2", "s3");intHolder.ExtendH(1,"s1");stringHolder.ExtendH(2,"s2");}}
}

（6） 泛型结构

using System;
using System.Collections.Generic;namespace APP
{struct PieceOfData{private T _data;public PieceOfData(T t)//结构的构造函数(注意;结构也可以有有构造函数){_data = t;}public T Data { get => _data;}}public class Program{public static void Main(){var intData = new PieceOfData(1);var stringData = new PieceOfData("你好");Console.WriteLine("intData={0}", intData.Data);Console.WriteLine("stringData={0}", stringData.Data);}}
}

（7） 泛型委托

代码举例：

using System;
using System.Collections.Generic;namespace APP
{public delegate R MyDele(T t);//定义一个泛型委托，返回值为R泛型类型，传入参数为T泛型类型public class Simple{public static string PrintInt1(int t){string s1 = "Print1:" + t;Console.WriteLine(s1);return s1;}public static string PrintInt2(int t){string s1 = "Print2:" + t;Console.WriteLine(s1);return s1;}}public class Program{public static void Main(){MyDele myDele = new MyDele(Simple.PrintInt1);myDele += Simple.PrintInt2;string s= myDele(3);//如果委托带有返回值，那么委托最后一个方法返回的值就是委托调用返回的值，因此在这行代码中，委托返回的是PrintInt2方法的返回值Console.WriteLine(s);}}
}

（8）泛型接口：
代码示例1：泛型类继承泛型接口

using System;
using System.Collections.Generic;namespace APP
{public interface IBase//泛型接口{T Show(T t);}public class sample : IBase//泛型类继承泛型接口{public T Show(T t){return t;}}public class Program{public static void Main(){var intSample = new sample();var strSample = new sample();Console.WriteLine(intSample.Show(1));Console.WriteLine(strSample.Show("你好"));}}
}

代码示例2：非泛型类继承泛型接口

using System;
using System.Collections.Generic;namespace APP
{public interface IBase//泛型接口{T Show(T t);}public class sample:IBase,IBase//非泛型类继承泛型接口{public int Show(int t){return t;}public string Show(string t){return t;}}public class Program{public static void Main(){var Sample = new sample();Console.WriteLine(Sample.Show(1));Console.WriteLine(Sample.Show("你好"));}}
}

54.c#中的“\r”和“\n”问题

如下面一段代码：

using System;
namespace APP
{class Program{static void Main(){Console.WriteLine("{0}", "12\n3678\r456");Console.WriteLine("{0}", "-------分隔------");Console.WriteLine("{0}", "12\\n\r456");Console.WriteLine("{0}", "12\\n456");Console.WriteLine("{0}", "\\");}}
}

55.本地变量和字段是否会自动初始化？

本地变量是不会自动初始化的，而字段是会自动初始化的。
例如double rad是本地变量，如果没有赋值，就不会自动初始化；
字段则可以自动初始化。

56.属性相比公共字段的优点：

57.枚举器和迭代器

58.LINQ

（1）LINQ(发音为link)表示语言集成查询；
（2）LINQ是.net框架的扩展，它允许我们可以使用SQL查询数据库的方式来查询数据集合；
（3）使用LINQ，可以从XML文档、数据库、程序对象的集合中查找数据；
（4）匿名类型经常用于LINQ查询的结果之中；
（5）如下是一段匿名类型的对象：

using System;
using System.Linq;namespace APP
{class Program{public static void Main(){var student = new { Name = "小明", Age = 19, Sex = "男" };//匿名类型的对象Console.WriteLine("{0},{1},{2}", student.Name, student.Age, student.Sex);}}
}

（6）form子句：
from子句指定了要作为数据源使用的数据集合。

using System;
using System.Linq;namespace APP
{class Program{public static void Main(){int[] arr= { 1, 3, 5, 7, 9 };var query = from item in arr //from子句指定了要作为数据源使用的数据集合where item < 7select item;foreach (var item in query){Console.WriteLine("{0}, ", item);}}}
}

（7）join（联结）子句：
LINQ中的Join接受两个集合然后创建一个新的集合，每一个元素包含两个原始集合中的原始成员。
看一段代码：

using System;
using System.Linq;namespace APP
{public class Student //学生类{public int StID;//学生编号public string StName;//学生姓名}public class CourseStudent//学生所学习的课程类{public int StID;//学生编号public string CourseName;//4课程名称}class Program{static void Main(){Student[] students = new Student[3]
{new Student{ StID=1,StName="小王" },new Student{ StID=2,StName="小刘" },new Student{ StID=3,StName="小明" },
};CourseStudent[] courseStudentes = new CourseStudent[5]{new CourseStudent{ StID=1,CourseName="历史" },new CourseStudent{ StID=2,CourseName="哲学" },new CourseStudent{ StID=1,CourseName="音乐" },new CourseStudent{ StID=3,CourseName="历史" },new CourseStudent{ StID=3,CourseName="音乐" },};//查找了所有选取历史课的学生姓名var query = from s in studentsjoin c in courseStudentes on s.StID equals c.StIDwhere c.CourseName == "历史"select s.StName;foreach(var q in query){Console.WriteLine("学习历史课的学生有：{0}", q);}}}
}

再看一段代码：

using System;
using System.Linq;namespace APP
{class Program{static void Main(){var GroupA = new int[] { 3, 4, 5, 6 };var GroupB = new int[] { 6, 7, 8, 9 };//查找了所有选取历史课的学生姓名var query = from int a in GroupAfrom int b in GroupBlet sum = a + bwhere sum >= 11//条件1where a == 4//条件2select new { a, b, sum };//匿名类型的对象foreach(var q in query){Console.WriteLine(q);}}}
}

（8）orderby子句:
orderby子句接受一个表达式并根据表达式顺序返回结果项。

using System;
using System.Linq;namespace APP
{class Program{static void Main(){var students = new[]{new{Name="小王",Age=21},new{Name="小李",Age=25},new{Name="小刘",Age=11},new{Name="小张",Age=14},new{Name="小何",Age=19},new{Name="小陈",Age=23},new{Name="小罗",Age=27},};var query = from student in studentsorderby student.Age//根据Age排序select student;foreach(var q in query){Console.WriteLine("姓名:{0},年龄:{1}", q.Name, q.Age);}}}
}

（9）select …group子句:

(10)group子句：
group子句按照一些标准进行分组。
(11)查询延续：into子句：
into子句可以接受查询的一部分结果并赋予另外一个名字，从而可以在查询的另一部中使用。

（12）再看一段代码：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading;namespace APP
{class Program{static void Main(){int x = 10;int[] intArr = { 1, 2, 3, 4, 5, 6, 7 };Person person1 = new Person() { name = "One",age = 10 };Person person2 = new Person() { name = "Two", age = 20 };Person person3 = new Person() { name = "Three", age = 20 };List people = new List();people.Add(person1);people.Add(person2);people.Add(person3);var lst = people.AsEnumerable().Where((a) => a.age == 20);foreach (var item in lst){Console.WriteLine("名称：{0}，年龄：{1}",item.name,item.age);}}}public  class Person{ public string name; public int age; }
}

（13）标准查询运算符：






（14）再看一段代码：

using System;
using System.Collections.Generic;
using System.Linq;namespace APP
{public class Person{private string _name;private int _age;private string _sex;public string Name { get => _name; set => _name = value; }public int Age { get => _age; set => _age = value; }public string Sex { get => _sex; set => _sex = value; }//重写ToString方法public override string ToString(){string str = this.Name + "," + this.Age + "," + this.Sex;return str;}}public class Program{public static void Main(){List lists = new List();lists.Add(new Person() { Name = "s1", Age = 13, Sex = "男" });lists.Add(new Person() { Name = "s1", Age = 11, Sex = "男" });lists.Add(new Person() { Name = "s3", Age = 17, Sex = "女" });lists.Add(new Person() { Name = "s4", Age = 9, Sex = "男" });lists.Add(new Person() { Name = "s5", Age = 31, Sex = "男" });var lists2 = lists.AsEnumerable().OrderBy(item => item.Age);foreach(var item in lists2){Console.WriteLine(item.ToString());}}}
}

59.异步编程

（1）进程是构成运行程序的资源的集合，这些资源包括虚地址空间、文件句柄和许多其他程序运行所需要的的东西。
（2）线程代表了真正的执行程序，一旦进程建立，系统会在Main方法的第一行语句处就开始线程的执行。

（3）同步方法：如果一个程序调用某个方法，等待其执行所有处理后才继续执行，那么就称这样的方法是同步的。
（4）C#中的async和await特性可以创建并使用异步方法，该特性由三种部分组成：

1. 调用方法：该方法会用来调用异步方法，然会在异步方法执行其他任务的时候继续操作；
2. 异步方法（async)：该方法异步执行其工作，然会立即返回到调用方法；
3. await表达式：用在异步方法内部，一般和async配合来使用，await指明需要异步执行的任务。一个异步方法可以包含多个表达式，但是如果一个都不包含的话，编译器就会发出警告。
   代码举例：

using System;
using System.Threading;
using System.Threading.Tasks;namespace ConsoleApp1
{class Program{public static async Task Test()//异步方法{Console.WriteLine("Test方法开始执行");//await指明需要异步执行的任务await Task.Run(() => Thread.Sleep(1000));//此处有await,因此程序执行到这里时，会跳出该Test方法，执行 Console.WriteLine("程序执行结束！");这一句代码 。Console.WriteLine("Test方法执行完毕");}static void Main(string[] args){Console.WriteLine("程序开始执行！");Program.Test();Console.WriteLine("程序执行结束！");Console.ReadKey();}}
}

（5） 异步编程

60.异常

（1）try语句：
try语句用来指明因避免出现异常而被保护的代码片段，并在发生异常时提供代码处理异常。

（2）try块后面必须跟catch块或finally块组合使用，不能单独使用
（3）代码举例：

using System;
namespace Application
{class app{static void Main(){try{int[] nums = { 1, 2, 3, 4, 5 };Console.WriteLine("开始执行~");Console.WriteLine(nums[5]);}catch (IndexOutOfRangeException e){Console.WriteLine("程序发生异常，数组越界了，请修正！");throw new Exception(); // 抛出异常}finally{Console.WriteLine("执行完毕~");}}}
}

运行结果：

61.预处理指令

（1）预处理指令指示编译器如何处理源代码。
（2）预处理指令：

（3）#define和#undef只能用在源文件的第一行，也就是任何C#代码之前使用，在C#代码开始后，#define和#undef就不能再使用。

62.反射和特性

（1）元数据：有关程序及其类型的数据称为元数据，它们保存在程序的程序集中。
（2）程序在运行时，可以查看其他程序集或其本身的元数据。一个运行的程序可以查看本身的元数据和其他程序的元数据的行为叫做反射。
（3）反射在System.Reflection命名空间中。
（4）Type类
（5）特性：
特性是一种允许我们向程序的程序集增加元数据的语言结构。它是用于保存程序结构信息的某种特殊类型的类。
特性的目的就是告诉编译器把程序结构的某组元数据嵌入到程序集。
（6）Obsolete特性：


（7）Conditional特性
（8）看一段代码，反射中SetValue和GetValue以及克隆的使用：

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;namespace _8_02
{public class WaferBase{public string Name = "Wafer";public double Thickness = 0.1;public WaferBase clone(){WaferBase waferBase1 = new WaferBase();foreach (var item in this.GetType().GetFields()){item.SetValue(waferBase1, item.GetValue(this));}return waferBase1;}}
}

using System;namespace _8_02
{class app{static void Main(){WaferBase waferBase = new WaferBase();WaferBase  waferBaseClone= waferBase.clone();Console.WriteLine(waferBaseClone.Name);Console.WriteLine(waferBaseClone.Thickness);}}}

运行结果：

63.字符串

（1）字符串string类型的一些成员：
（2）Spilt方法：
该方法很有用，该方法会将一个字符串分割成若干个子字符串，并将他们以数组的形式返回。将一组按照预定位置分隔字符串的分隔符传给Spilt方法，就可以指定如何处理输出数组中的空元素（当然，原始字符串依然不会改变）。代码举例如下：

using System;
using System.Reflection;
namespace APP
{class Program{static void Main(){string str = "Hi there! this,is :a string!";char[] delimiters = { ',',':',' ','!'};string[] words = str.Split(delimiters, StringSplitOptions.RemoveEmptyEntries); //RemoveEmptyEntries表示返回值不包括含有空字符串的数组元素Console.WriteLine("单词个数是：{0}", words.Length);foreach(var item in words){Console.WriteLine(item);}}}
}

（3）StringBuilder类
StringBuilder类位于System.Text命名空间中，它可以帮助程序员动态、有效地产生字符串，并避免创建许多副本。代码举例如下：

using System;
using System.Text;
namespace APP
{class Program{static void Main(){StringBuilder str = new StringBuilder("小西八！");Console.WriteLine(str.ToString());str.Replace("西八", "八嘎");//替换部分字符串Console.WriteLine(str);}}
}

（4）把字符串解析为数据值
解析允许我们接受表示值的字符串，并转化为实际的值，通过Parse静态方法。如：

using System;
using System.Text;
namespace APP
{class Program{static void Main(){string s1 = "24.3";string s2 = "12.4";double d1 = double.Parse(s1);//把字符串转化为double类型double d2 = double.Parse(s2);Console.WriteLine(d1 + d2);}}
}

但是，Parse方法有一个缺点，当转换不成功（即不能把string类型转化为其他类型）时会抛出一个异常，而在编程中要尽量避免异常。TryParse方法可以解决这个问题。

64.List < T >

（1）List < T >是泛型集合，用法如下代码所示：

using System;
using System.Collections.Generic;namespace APP
{public class Person{private string _name;private int _age;private string _hobby;public string Name { get => _name; set => _name = value; }public int Age { get => _age; set => _age = value; }public string Hobby { get => _hobby; set => _hobby = value; }public string ShowMessage(){return "Name=" + Name + ",Age=" + Age + ",Hobby=" + Hobby;}}class Program{static void Main(){List  list= new List();list.Add(new Person { Name = "小明", Age = 18, Hobby = "听音乐" });list.Add(new Person { Name="小刘",Age=14,Hobby="爬山"});list.Add(new Person { Name = "小王", Age = 19, Hobby = "游泳" });foreach(var item in list){Console.WriteLine(item.ShowMessage());}}}
}

（2）List的一些常用属性和方法：

（3）可以用List中的AsEnumerable()方法+lambda表达式结合的语句进行一些操作，如下代码：

using System;
using System.Collections.Generic;
using System.Linq;namespace practice7_25
{class Person{private string _name;private int _age;private int _id;public string Name { get => _name; set => _name = value; }public int Age { get => _age; set => _age = value; }public int ID { get => _id; set => _id = value; }}public class Program{static void Main(string[] args){List lists = new List();lists.Add(new Person { Name="小明",Age=18,ID=5});lists.Add(new Person { Name = "小王", Age = 20, ID = 5 });lists.Add(new Person { Name = "小六", Age = 13, ID = 8 });lists.Add(new Person { Name = "小1", Age = 11, ID = 8 });lists.Add(new Person { Name = "小2", Age = 17, ID = 2 });int counts = lists.Count();Console.WriteLine("元素个数为：{0}", counts);var result = lists.AsEnumerable().OrderBy(p => p.ID);foreach (var item in result){Console.WriteLine(item.Name + " " + item.Age + " " + item.ID);}}}
}

65.方法重载和重写的区别

重写：当一个子类继承一父类，而子类中的方法与父类中的方法的名称，参数个数、类型都完全一致时，就称子类中的这个方法重写了父类中的方法。
重载：一个类中的方法与另一个方法同名，但是参数表不同，这种方法称之为重载方法。

66.简述c#中类(class)和结构(struct)的异同

异:(1)类型不同:
类是引用类型,在堆上分配地址;
结构是值类型,在栈上分配地址;
(2)继承性不同:
类:是完全可扩展的，也可以继承其他类和接口，自身也能被继承；
结构：不能从另外一个结构或者类继承，本身也不能被继承(但能够继承接口，方法和类继承接口一样)。
(3)内部结构不同：
类： 有默认的构造函数和析构函数，可以使用访问修饰符 ，必须使用new 初始化；
结构： 没有默认的构造函数，但是可以添加构造函数，没有析构函数 ，可以不使用new 初始化。
同:基类型都是对象（object）

67.简述c#中接口和类的异同

不同点：
不能直接实例化接口。
接口不包含方法的实现。
接口可以多继承，类只能单继承。
类定义可以在不同的源文件之间进行拆分。
相同点：
接口、类都可以从多个接口继承。
接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员。
接口和类都可以包含事件、索引器、属性。

68. 一道C#编程测验题

using System;
namespace APP
{public class student{public int age;}class Program{static void ChangeAge(student s){s.age = 20;}static void ChangeAge_1(student s){s = new student();s.age = 20;}static void ChangeAge_2(ref student s){s = new student();s.age = 20;}static void ChangeAge_3(out student s){s = new student();s.age = 20;}static void Main(string[] args){student s = new student();s.age = 18;student s1 = new student();s1.age = 18;student s2 = new student();s2.age = 18;student s3 = new student();s3.age = 18;ChangeAge(s);ChangeAge_1(s1);ChangeAge_2(ref s2);ChangeAge_3(out s3);Console.WriteLine("student s age is {0}", s.age);Console.WriteLine("student s1 age is {0}", s1.age);Console.WriteLine("student s2 age is {0}", s2.age);Console.WriteLine("student s3 age is {0}", s3.age);}}
}

69.C#中如何判断传入值的数据类型

（1）GetType方法：获取当前变量的类型对象

（2）typeof运算符，在此笔记第41条已提到。

70.C#中唯一的非派生类是Object类

因为C#中所有的类都直接或者间接派生自Object类，因此Object类类是C#中唯一的非派生类。

71.C#转义字符的两种处理方式

当声明一个字符串变量时有一些字符是不能以平常的方式包含在变量中的。为了解决这个问题，C#提供了两种不同的C#转义字符方法:：
（1）第一种方法是使用

代码举例一可参考笔记第56条；
代码举例二：

            string str1 = "C:\\Program Files\\Microsoft\\";Console.WriteLine("str1的值是{0}:",str1);string str2 = "C:\nProgram Files\\nMicrosoft\\n";Console.WriteLine("str2的值是{0}:", str2);string str3 = "\"\n";Console.WriteLine("str3的值是{0}:", str3);

注意：当出现"\\n"时，结果是显示的是\n，而不会出现换行
（2）第二种C#转义字符方法是使用@

代码举例：

            string str1 = "C:\\Program Files\\Microsoft\\";Console.WriteLine("str1的值是{0}:", str1);string str2 = @"C:\Program Files\Microsoft\";Console.WriteLine("str2的值是{0}:", str2);

72.抽象成员，哪些成员可以声明为抽象的，虚成员和抽象成员的区别

（1）抽象成员是抽象类中的成员，抽象成员是指设计为被覆写的函数成员，抽象成员具有以下特征：

• 抽象成员必须是函数成员，字段和常量不能为抽象成员；
• 抽象成员必须用Abstract标记；
• 抽象成员不能实现代码块；
• 抽象成员必须被子类用override关键字重写;
  例如下图：
  
  （2）虚成员和抽象成员的区别：
  抽象方法是只有方法名称，没有方法体（也就是没有方法具体实现），子类必须用override关键字重写父类抽象方法。
  虚函数有方法体，但是子类可以覆盖，也可不覆盖。

73.构造函数重载、静态构造函数、构造函数分别什么时候执行？

先看代码展示：

using System;
using System.Collections.Generic;
using System.Linq;namespace practice7_25
{public class A{static A(){Console.WriteLine("SA");}public A(){Console.WriteLine("baseA");}public virtual void Fun(){Console.WriteLine("A.Fun");}}public class B : A{static B(){Console.WriteLine("SB");}public B(){Console.WriteLine("baseB");}public override void Fun(){Console.WriteLine("B.Fun");}}public class Program{static void Main(string[] args){A a = new A();a.Fun();Console.WriteLine("————————————————————————————————");A b = new B();b.Fun();}}
}

十二字口诀：“先静后构，静外到内，构内到外”;
先静后构：
一个类同时存在静态构造函数和普通构造函数，对象实例化后，先执行静态构造函数（先静），再执行普通构造函数（后构）；
故上文对象A实例后输出的是SA baseA。

静外到内：
父类和子类都存在静态构造函数的时候，实例化子类后，先执行子类静态构造函数（静外），再执行父类静态构造函数（到内）；
上文B继承了A，B和A同时存在静态构造函数但是由于一个静态构造函数在一个应用程序的完整生命周期中，最多只会被自动执行一次，因此基类的静态构造函数只会在基类被初始化的时候调用且调用一次，所以实例化B后，静态构造函数输出结果是是SB ，而不是SB SA。

构内到外：
实例化子类后，先执行父类的普通构造函数（构内），再执行子类的构造函数（到外）；
上文B继承了A，实例化B后，普通构造函数输出结果是baseA baseB。

• 对于构造函数重载，先执行基类的构造函数，再执行子类的构造函数;
• 对于析构函数，先执行子类的析构函数，再执行基类的析构函数。

74.测验题：委托的创建和初始化

public class Program{public delegate int MyDelegate(int x);static void Main(){Program program = new Program();//以下这5种方式声明委托都是可以的：MyDelegate myDelegate1 = delegate (int x) { return x + 1; };MyDelegate myDelegate2 =(int x)=>{ return x + 1; };MyDelegate myDelegate3 = (x) => { return x + 1; };MyDelegate myDelegate4 = x=> { return x + 1; };MyDelegate myDelegate5 = x => x + 1;Console.WriteLine(myDelegate1(1));Console.WriteLine(myDelegate2(1));Console.WriteLine(myDelegate3(1));Console.WriteLine(myDelegate4(1));Console.WriteLine(myDelegate5(1));}}

75.测验题：判断类型是否是隐式转换

隐式转换：类型的转换不会丢失数据或精度。

 public class Program{static void Main(){//doube转intdouble a1 = 2.3456;int a2 = (int)a1;Console.WriteLine("double转int: {0}---{1}", a1, a2);//float转doublefloat b1 = 2.3456f;double b2 = (double)b1;Console.WriteLine("float转double: {0}---{1}", b1, b2);//unshort转intushort c1 = 2;int c2 = (int)c1;Console.WriteLine("unshort转int: {0}---{1}", c1, c2);//int转longint d1 = 2;long d2 = (long)d1;Console.WriteLine("int转long: {0}---{1}", d1, d2);}}

76.LINQ的部分知识点考察

   public class Program{static void Main(){int[] array1 = new[] { 3,2,5,33,56,43,4,5 };//Take是获取到第几个下标为止,取得的值不包括当前下标值的内容var array2 = array1.Take(5).Where(x => x > 20).ToList();//在本行代码中，array1.Take(5)返回的集合是：3,2,5,33,56，因此最终array2接受的只有33和56大于20foreach (var item in array2){Console.WriteLine(item);}}}

77.哪些成员可以在接口内声明，列举接口和抽象类的区别？

（1）可以在接口内声明的成员：方法、属性、事件、索引器。
（2）接口和抽象类的区别：

1. 接口中不能声明常量和字段，抽象类中可以声明任何类成员；
2. 在接口中只能定义成员，但不能具体实现，在抽象类中除了抽象方法外，其他成员允许有具体的实现；
3. 接口中没有实例构造函数，也就是说没有构造函数，抽象类中有构造函数；
4. 接口成员不能使用任何访问修饰符，抽象类中的类成员可以使用任意的访问修饰符；
5. 继承接口的类或结构必须隐式或显式实现接口中的所有成员，否则需要将实现类定义为抽象类，并将接口中未实现的成员以抽象的方式实现，继承抽象类的类必须重写实现抽象类中的所有抽象方法，或者抽象类继承抽象类，可以重写部分抽象方法；
6. 接口不能作为派生类继承，抽象类可以继承非抽象类或抽象类；
7. 接口可以作为基类来多继承：接口、类和结构，抽象类可以作为基类只能实现单继承，只能让非抽象类或者抽象类继承。

78.什么叫显式转换，什么叫隐式转换？装箱和拆箱又是什么？

（1）显式转换：类型的转换可能会丢失数据或精度，语言不会自动做的转换需要用到显示转换。
（2）隐式转换：类型的转换不会丢失数据或精度，因此语言会自动给做的转换叫做隐式转换。
（3）装箱：值类型到引用类型的隐式转换。任何值类型都可以被隐式转换为object类型，System.ValueType或InterfaceT；
（4）拆箱：把装箱后的对象转换回值类型的过程。拆箱是显式转换。

79.进程和线程分别是什么？谈谈进程和线程的区别与联系。

（1）进程：构成运行程序的资源的集合。这些资源包括虚地址空间，文件句柄和许多其他程序运行所需的东西。
（2）线程：在进程的内部，系统创建了一个称为线程的内核对象，它代表了真正执行的程序。
（3）进程和线程的区别与联系：

1. 默认情况下，一个进程只包含一个线程，从程序的开始一直执行到结束；
2. 线程可以派生其他线程，因此在任意时刻，一个进程都可能包含不同状态的多个线程来执行程序的不同部分；
3. 如果一个进程拥有多个线程，他们将共享进程的资源；
   系统为处理器执行所规划的单元是线程，不是进程。

80.一道c#试题

using System;
namespace  day
{class day1{static void Main(){int n1=1,n2=2;bool re1=n1>n2 && n1++>1;Console.WriteLine(n1);//此处 false&&?,不管false与谁且，结果仍未fasle,所以，语句“n1++>1”并没有执行，所以此处n1的结果为1bool re2=n1

using System;
using System.Linq;
using System.Threading;namespace practice01
{class Program{private static CancellationTokenSource cts;//1.声明CancellationTokenSource对象static void Main(string[] args){while (true){Console.WriteLine("1.开始运行多线程");Console.WriteLine("2.取消多线程");switch (Console.ReadLine()){case "1":BeginThread();break;case "2":CancelThread();break;default:break;}}// Console.ReadKey();}/// 
/// 回调停止方法/// private static void CallStopThread(){Console.WriteLine("回调停止方法");}/// 
/// 取消方法/// 
private static void CancelThread(){cts.Cancel();//4.Cancel()方法调用会设置IsCancellationRequested为True;}/// 
/// 开始运行线程方法/// 
private static void StartThread(){for (int i = 0; i < 1000000; i++){if (cts.IsCancellationRequested) break;//如果为true，就跳出当前循环Console.WriteLine($"开始运行线程方法,线程ID：{Thread.CurrentThread.ManagedThreadId}");Thread.Sleep(1000);}}/// 
/// 开始运行线程/// 
private static void BeginThread(){Console.WriteLine("开始运行1方法");cts = new CancellationTokenSource(); //2.实例化 CancellationTokenSource 对象，此对象管理取消通知并将其发送给单个取消标记。cts.Token.Register(CallStopThread);//3.注册回调事件Thread[] ths = new Thread[3];for (int i = 0; i < ths.Count(); i++){ths[i] = new Thread(StartThread);ths[i].Start();}}}
}

int[] arrays = { 2, 8, 29, 19, 12, 13, 99, 89, 105, 108, 81 };
Console.WriteLine(string.Join(",", arrays));

using System;

using classA = namespaceA.MyClass;//给namespaceA下的MyClass起一个别名叫classA
using classB = namespaceB.MyClass;

using (Class1 cls1 = new Class1(), cls2 = new Class1())
{}

 TestServiceImpI t= sp.GetService();TestServiceImpI t1 = sp.GetService();bool result= object.ReferenceEquals(t1, t);Console.WriteLine(result);

record RecordPerson
{public string Name { get; init; }public int Age { get; init; }
}record RecordPerson2(string Name, int Age);public static void MainTest()
{var p1 = new RecordPerson(){Name = "Tom",Age = 12,};Console.WriteLine(p1);var p2 = p1 with { Age = 10 };Console.WriteLine(p2);var p3 = new RecordPerson() { Name = "Tom", Age = 12 };Console.WriteLine(p3);Console.WriteLine($"p1 Equals p3 =:{p1 == p3}");RecordPerson2 p4 = new("Tom", 12);Console.WriteLine(p4);
}

public record Person(string FirstName, string LastName);Person p1 = new Person("Yang", "Zack");
Person p2 = new Person("Yang","Zack");
Person p3 = new Person("Gates", "Bill");
Console.WriteLine(p1);
Console.WriteLine(p1==p2);
Console.WriteLine(p1==p3);
Console.WriteLine(p1.FirstName);

    public class A{protected  virtual  void M(){Console.WriteLine("A.M()");}protected  virtual  void N(){Console.WriteLine("A.N()");}}public class B:A {protected override void M(){Console.WriteLine("B.M()");}protected sealed override void N(){Console.WriteLine("B.N()");}}public sealed class C:B{protected override void M(){Console.WriteLine("C.M()");}protected override void N()  //会报错 ："C.N():"继承成员"B.N()"是密封的，无法进行重写{Console.WriteLine("C.N()"); }}

using System;
namespace Example
{public interface IServiceClass{string ServiceInfo();}public class ServiceClassA : IServiceClass{public string ServiceInfo(){return "我是ServiceClassA";}}public class ServiceClassB : IServiceClass{public string ServiceInfo(){return "我是ServiceClassB";}}public interface IClinetClass{IServiceClass myServiceClass { get; set; }}public class ClientClass: IClinetClass{private IServiceClass _myServiceClass;public IServiceClass myServiceClass{get { return _myServiceClass; }set { _myServiceClass = value; }}public void Set_ServiceImpl(IServiceClass serviceClass){this.myServiceClass = serviceClass;}public void ShowInfo(){Console.WriteLine(myServiceClass.ServiceInfo());}}public class Program{public static void Main(){IServiceClass serviceClassA = new ServiceClassA();IServiceClass serviceClassB = new ServiceClassB();ClientClass client = new ClientClass();client.Set_ServiceImpl(serviceClassA);client.ShowInfo();client.Set_ServiceImpl(serviceClassB);client.ShowInfo();}}
}

using System;
namespace Example
{public interface IServiceClass{string ServiceInfo();}public class ServiceClassA : IServiceClass{public string ServiceInfo(){return "我是ServiceClassA";}}public class ServiceClassB : IServiceClass{public string ServiceInfo(){return "我是ServiceClassB";}}public class ClientClass{private IServiceClass _serviceImpl;public IServiceClass ServiceImpl{get { return _serviceImpl; }set { _serviceImpl = value; }}public void Set_ServiceImpl(IServiceClass serviceClass){this.ServiceImpl = serviceClass;}public void ShowInfo(){Console.WriteLine(ServiceImpl.ServiceInfo());}}public class Program{public static void Main(){IServiceClass serviceClassA = new ServiceClassA();IServiceClass serviceClassB = new ServiceClassB();ClientClass client = new ClientClass();client.Set_ServiceImpl(serviceClassA);client.ShowInfo();client.Set_ServiceImpl(serviceClassB);client.ShowInfo();}}
}

using System;
namespace Example
{public interface IServiceClass{string ServiceInfo();}public class ServiceClassA : IServiceClass{public string ServiceInfo(){return "我是ServiceClassA";}}public class ServiceClassB : IServiceClass{public string ServiceInfo(){return "我是ServiceClassB";}}public class ClientClass{private IServiceClass _serviceImpl;public ClientClass(IServiceClass serviceClass){this._serviceImpl = serviceClass;}public void ShowInfo(){Console.WriteLine(_serviceImpl.ServiceInfo());}}public class Program{public static void Main(){IServiceClass serviceClassA = new ServiceClassA();IServiceClass serviceClassB = new ServiceClassB();ClientClass client1 = new ClientClass(serviceClassA);client1.ShowInfo();ClientClass client2 = new ClientClass(serviceClassB);client2.ShowInfo();}    }
}

namespace yield关键字
{public class Program{public static IEnumerable enumerableFuc(){yield return 1;yield return 2;yield return 3;}public static void Main(){foreach (int item in enumerableFuc()){Console.WriteLine(item);}Console.ReadKey();}}
}

namespace yield关键字
{public class Program{public static IEnumerable enumerableFuc(){yield return 1;yield return 2;yield break;yield return 3;}public static void Main(){foreach (int item in enumerableFuc()){Console.WriteLine(item);}Console.ReadKey();}}
}

using System;namespace PrototypePattern
{public class Person : ICloneable{private string _name="小明";public string Name{get { return _name; }set { _name = value; }}private string _sex="男";public string Sex{get { return _sex; }set { _sex = value; }}private int _age=18;public int Age{get { return _age; }set { _age = value; }}private List _hobbies=new List() { "唱歌","跳舞","做饭"};public List Hobbies{get { return _hobbies; }set { _hobbies = value; }}public void Show(){string showHobbies = "";foreach (var item in Hobbies){showHobbies += item.ToString();}Console.WriteLine("姓名:{0},性别:{1},年龄:{2},爱好:{3}", Name, Sex, Age, showHobbies);}//克隆信息public object Clone(){return (object)this.MemberwiseClone();//MemberwiseClone（）这个方法就是创建当前对象的浅表副本}}public class Client{public static void Main(){Person person1 = new Person();person1.Hobbies.Add("爬山");person1.Show();Person person2 = (Person)person1.Clone();//将person1的信息拷贝至person2上person2.Show();}}
}

姓名:小明,性别:男,年龄:18,爱好:唱歌跳舞做饭爬山
姓名:小明,性别:男,年龄:18,爱好:唱歌跳舞做饭爬山

using System;namespace PrototypePattern
{public class Person : ICloneable{private string _name="小明";public string Name{get { return _name; }set { _name = value; }}private string _sex="男";public string Sex{get { return _sex; }set { _sex = value; }}private int _age=18;public int Age{get { return _age; }set { _age = value; }}private List _hobbies=new List() { "唱歌","跳舞","做饭"};public List Hobbies{get { return _hobbies; }set { _hobbies = value; }}public void Show(){string showHobbies = "";foreach (var item in Hobbies){showHobbies += item.ToString();}Console.WriteLine("姓名:{0},性别:{1},年龄:{2},爱好:{3}", Name, Sex, Age, showHobbies);}//克隆信息public object Clone(){Person p= (Person)this.MemberwiseClone();//MemberwiseClone（）这个方法就是创建当前对象的浅表副本p.Hobbies = new List();if (Hobbies != null){foreach (var item in Hobbies){p.Hobbies.Add(item);}}return p;}}public class Client{public static void Main(){Person person1 = new Person();person1.Hobbies.Add("爬山");person1.Show();Person person2 = (Person)person1.Clone();//将person1的信息拷贝至person2上person2.Show();}}
}

姓名:小明,性别:男,年龄:18,爱好:唱歌跳舞做饭爬山
姓名:小明,性别:男,年龄:18,爱好:唱歌跳舞做饭爬山

using System;namespace LazyUsage
{class LazyDemo{static void Main(){Lazy lazyData = new Lazy();Console.WriteLine("Main-lazyData被初始化了吗? value = " + lazyData.IsValueCreated);lazyData.Value.Print();//此处访问时才会将Data真正的初始化Console.WriteLine("Main-lazyData被初始化了吗? value = " + lazyData.IsValueCreated);Console.ReadKey();}}class Data{public Data(){Console.WriteLine("Data::.ctor->Initialized");}public void Print(){Console.WriteLine("Data::Print->println");}}
}

Main-lazyData被初始化了吗? value = False
Data::.ctor->Initialized
Data::Print->println
Main-lazyData被初始化了吗? value = True

using System;namespace LazyUsage
{class LazyDemo{static void Main(){//指定委托来初始化DataLazy lazyData = new Lazy(() =>{Console.WriteLine("Main->lazyData将被初始化");return new Data("Test");});Console.WriteLine("Main->lazyData被初始化了吗? value = " + lazyData.IsValueCreated);lazyData.Value.Print();Console.WriteLine("Main->lazyData被初始化了吗? value = " + lazyData.IsValueCreated);Console.ReadKey();}}class Data{public string Name { get; private set; }public Data(string name){Name = name;Console.WriteLine("Data::.ctor->Initialized,name = " + name);}public void Print(){Console.WriteLine("Data::Print->name = " + Name);}}
}

Main->lazyData被初始化了吗? value = False
Main->lazyData将被初始化
Data::.ctor->Initialized,name = Test
Data::Print->name = Test
Main->lazyData被初始化了吗? value = True

using System.Runtime.CompilerServices;namespace prop
{public class Practice{//创建一个字典public Dictionary MyDict = new Dictionary();public Practice(){//向字典中添加元素MyDict.Add("小明", "听音乐");MyDict.Add("小红", "跳舞");}}public class Program{public static void Main(){Practice practice=new Practice();//检索键:方式1Console.WriteLine(practice.MyDict["小明"]);Console.WriteLine(practice.MyDict["小红"]);//检索键:方式2foreach (var k in practice.MyDict.Keys){Console.WriteLine(k);}//检索值foreach (var v in practice.MyDict.Values){Console.WriteLine(v);}//字典中的元素个数Console.WriteLine(practice.MyDict.Count);//删除元素Console.WriteLine(practice.MyDict.Remove("小明"));//判断字典中是否有这个键，返回布尔值Console.WriteLine(practice.MyDict.ContainsKey("小明")); //判断字典中是否有这个值，返回布尔值Console.WriteLine(practice.MyDict.ContainsValue("小明"));//当在字典中不能确定是否存在该键时需要使用TryGetValue，以减少一次不必要的查找，同时避免了判断Key值是否存在而引发的“给定关键字不在字典中。”的错误。（TryGetValue是根据ID返回相应的数据，如果没有ID则返回默认值）practice.MyDict.TryGetValue("小红", out string tryResult);Console.WriteLine(tryResult);}}
}

class CD_Ctor
{public static void Main(){var task = ApiWrapper(); Console.WriteLine("Foo4:"+Thread.CurrentThread.ManagedThreadId);Console.WriteLine(task.Result);}public static Task ApiWrapper(){var tcs=new TaskCompletionSource();var api = new EventClass();api.Done += (args) => { tcs.TrySetResult(args); };api.Do();return tcs.Task;}public class EventClass{public Action Done = (args) => { };public void Do(){Console.WriteLine("EventClass:"+Thread.CurrentThread.ManagedThreadId);Done("Done");}}
}

using System.Collections.Concurrent;
using System.Runtime.CompilerServices;namespace prop
{public class Program{//选择车票public static async Task ChoiceTicket(TaskCompletionSource tcs){Console.WriteLine("选购火车票");Console.WriteLine("跳转到到支付页面");await tcs.Task;//到这里会等待直到其他地方设置了Task的状态Console.WriteLine("订票完成");return true;}//选择支付页面public static async Task PayForMoney(TaskCompletionSource tcs){await Task.Delay(3000).ContinueWith((t) => Console.WriteLine("选购支付宝支付"));tcs.SetResult(false);//SetResult方法被调用后。就会让await等待的代码即await tcs.Task继续往下执行。Console.WriteLine("支付完成");Console.WriteLine("跳到火车票软件完成");}public static void Main(){TaskCompletionSource tcs = new();Task.Run(async () => await ChoiceTicket(tcs));Task.Run(async () => await PayForMoney(tcs));Console.Read();}}
}

选购火车票
跳转到到支付页面
选购支付宝支付
订票完成
支付完成
跳到火车票软件完成

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;class Test
{private static TaskCompletionSource _taskCompletionSource;private static async void Foo(){await _taskCompletionSource.Task;Console.WriteLine("F");}static void Main(){_taskCompletionSource = new TaskCompletionSource();Foo();var taskList = new List();for (int i = 0; i < 100; i++){var task = Task.Run(() =>{_taskCompletionSource.TrySetResult(true);});taskList.Add(task);}Task.WaitAll(taskList.ToArray());Console.Read();}}

F

using System;
using System.Collections;
using System.Diagnostics;
using System.Security.Cryptography;namespace App
{class CD_Ctor{public static void Main(){IEnumerable enumerable = DataTimeEnum();foreach (var item in enumerable){Console.WriteLine(item);}}public static IEnumerable DataTimeEnum(){for (int i = 0; i < 10; i++){string result = DateTime.Now.ToString("F");Thread.Sleep(1000);yield return result;}}}
}

2022年10月18日 20:47:19
2022年10月18日 20:47:20
2022年10月18日 20:47:21
2022年10月18日 20:47:22
2022年10月18日 20:47:23
2022年10月18日 20:47:24
2022年10月18日 20:47:25
2022年10月18日 20:47:26
2022年10月18日 20:47:27
2022年10月18日 20:47:28

using System;namespace 测试
{class MainClass{public static void Main(string[] args){//1.通过对象获取到这个对象所属类的Type对象//TestClass c = new TestClass();//Type t = c.GetType();//2.通过Type类中的静态方法GetType获取到类的Type对象//Type t = Type.GetType("TestClass");//3.通过typeof关键字获取到类的Type对象Type t = typeof(TestClass);Console.WriteLine("----------获取类名(不带命名空间)");Console.WriteLine(t.Name);Console.WriteLine("----------获取类名(带命名空间)");Console.WriteLine(t.FullName);Console.WriteLine("----------获取程序集");Console.WriteLine(t.Assembly);Console.WriteLine("----------获取基类类型");Console.WriteLine(t.BaseType);Console.WriteLine("----------获取类中字段");var fields = t.GetFields();foreach (var temp in fields){Console.WriteLine(temp.Name);}Console.WriteLine("----------获取类中属性");var properties = t.GetProperties();foreach (var temp in properties){Console.WriteLine(temp.Name);}Console.WriteLine("----------获取类中方法");var methods = t.GetMethods();foreach (var temp in methods){Console.WriteLine(temp.Name);}Console.WriteLine("----------获取类中成员");var members = t.GetMembers();foreach (var temp in members){Console.WriteLine(temp.Name);}Console.WriteLine("----------获取类中嵌套类");var nesteds = t.GetNestedTypes();foreach (var temp in nesteds){Console.WriteLine(temp.Name);}Console.WriteLine("----------获取类中构造函数");var constructors = t.GetConstructors();foreach (var temp in constructors){Console.WriteLine(temp.Name);}}}public class TestClass{public string _str;public int num { get; set; }public string Fun(){return "你好";}public TestClass(){}public class TestNestedClass{}}
}

----------获取类中属性
num
----------获取类中方法
get_num
set_num
Fun
GetType
ToString
Equals
GetHashCode
----------获取类中成员
get_num
set_num
Fun
GetType
ToString
Equals
GetHashCode
.ctor
num
_str
TestNestedClass
----------获取类中嵌套类
TestNestedClass
----------获取类中构造函数
.ctor

 [Serializable]class Sunshine{...}

using System;namespace 测试
{[AlarmID((long)AlarmIDs.UVOpenFailure, (long)AlarmIDs.UVCloseFailure, (long)AlarmIDs.UVProcedureAlarm)]class CalculationFailureAlarm: IAlarmProcedure{}
}

/// 
/// 下面这段代码复刻了一个流程：在类的前面加上[AlarmID((long)AlarmIDs.UVOpenFailure, (long)AlarmIDs.UVCloseFailure, (long)AlarmIDs.UVProcedureAlarm)]这些特性，注入这些特性，C#就自动为我们复刻了以下流程/// 
Dictionary AlarmID2Type = new Dictionary(); //实例化一个字典public void xyz(){var assembly = System.Reflection.Assembly.GetExecutingAssembly();//获取整个应用程序所有的类型foreach (var type in assembly.GetTypes()) //遍历所有的类型{if (type.IsAssignableFrom(typeof(IAlarmProcedure)) //如果有的类型继承自接口IAlarmProcedure且自定义了一些AlarmIDAttribute属性并转化为AlarmIDAttribute类型的alarmID集合&& type.GetCustomAttribute(typeof(AlarmIDAttribute)) is AlarmIDAttribute alarmID){foreach (var id in alarmID.AlarmID){AlarmID2Type[id] = type;//将这些数据存到字典中}}}}public void HandleID(long alarmID){(Activator.CreateInstance(AlarmID2Type[alarmID]) as IAlarmProcedure).HandleAsync(null, null); //根据传入的alarmID创造实例并调用相应的HandleAsync方法}

public delegate void action(string str);public event action EventTs{add{···  //执行+=运算符}remove{···  //执行-=运算符}}

using Microsoft.VisualBasic;
using System.ComponentModel;
using System.Net;
using System.Reflection;
using System.Xml.Serialization;
using System.Xml;namespace _11_3
{class Program{static void Main(string[] args){#region 序列化Student student = new Student{Name = "Tom",Age = 20,Sex = 1};XmlSerializer xmlSerializer = new XmlSerializer(typeof(Student));using (FileStream stream = new FileStream(@"d:\123.xml", FileMode.OpenOrCreate)){xmlSerializer.Serialize(stream, student);}#endregion#region 反序列化using (FileStream stream = new FileStream(@"d:\123.xml", FileMode.OpenOrCreate))//FileMode.OpenOrCreate方式，表示如果文件存在就打开，不存在就创建该文件{XmlReader xmlReader = new XmlTextReader(stream);student = xmlSerializer.Deserialize(xmlReader) as Student;}Console.WriteLine("Name: " + student.Name);Console.WriteLine("Sex: " + student.Sex);Console.WriteLine("Age: " + student.Age);#endregionConsole.WriteLine("操作完成");Console.ReadLine();}}[Serializable]      // 在类前加上[Serializable] 特性表示该类可以被序列化[XmlRoot("AAABBBCCC")]    // 设置为XML中的根元素名称public class Student{[XmlIgnore] //在属性前加上一个[XmlIngore]特性表示该属性不会被序列化public string Name { get; set; }public int Age { get; set; }public int Sex { get; set; }}
}

Name:
Sex: 1
Age: 20
操作完成

小知识：//1 byte=1字节  1024byte=1KB  1024Kb=1MB  1024MB=1GB  1024GB=1T因为C#提供的文件的大小是以B为单位的，所以显示文件大小的时候会出现一大串数字很不方便。所以，FileInfo类中的Length属性为了方便地显示文件大小而出现函数说明，如果文件大小是0-1024B 以内的   显示以B为单位如果文件大小是1KB-1024KB之间的 显示以KB为单位如果文件大小是1M-1024M之间的   显示以M为单位如果文件大小是1024M以上的      显示以GB为单位

using System.Text.RegularExpressions;namespace _002正则表达式
{public class Program{static void Main(string[] args){//相对路径：找当前程序所在路径FileInfo fileInfo = new FileInfo("TextFile1.txt");Console.WriteLine(fileInfo.Exists);//判断文件是否存在Console.WriteLine(fileInfo.DirectoryName);//获得文件所在路径Console.WriteLine(fileInfo.Name);//获取文件名+后缀Console.WriteLine(fileInfo.Length);//获取文件大小Console.WriteLine(fileInfo.IsReadOnly);//获取文件是否只读fileInfo.CopyTo("Test.txt");//将该文件的内容复制到另外一个新的文件fileInfo.Delete();//删除的是输出路径的文件，工程下的文件还是存在的FileInfo fileInfo1 = new FileInfo("Test02.txt");if (fileInfo1.Exists == false)//如果不存在{fileInfo1.Create();//创建当前文件}fileInfo1.MoveTo("Test02.txt");//重命名操作Console.ReadKey();}}
}

using System.Text.RegularExpressions;namespace _002正则表达式
{public class Program{static void Main(string[] args){DirectoryInfo directoryInfo01 = new DirectoryInfo(@"C:\Users\hezexi\Desktop\C#高级教程\002正则表达式\bin\Debug\net6.0");Console.WriteLine(directoryInfo01.Exists);//目录是否存在Console.WriteLine(directoryInfo01.Name);//目录的名称Console.WriteLine(directoryInfo01.Parent);//目录的上一级目录Console.WriteLine(directoryInfo01.Root);//目录的根目录Console.WriteLine(directoryInfo01.CreationTime);//目录的创建时间directoryInfo01.CreateSubdirectory("小何");//在该目录下创建一个子目录，名为小何DirectoryInfo directoryInfo02 = new DirectoryInfo("Test-01");if (directoryInfo02.Exists == false){directoryInfo02.Create();//创建目录}Console.ReadKey();}}
}

using System.Text.RegularExpressions;namespace _002正则表达式
{public class Program{static void Main(string[] args){var strs01= File.ReadAllLines("TextFile1.txt");//读取文件，把每一行文本读取成一个字符串，最后组成一个字符串数组foreach (var item in strs01){Console.WriteLine(item);}var strs02= File.ReadAllText("TextFile1.txt");//读取所有的内容并组成一个字符串Console.WriteLine(strs02);File.WriteAllText("TestFile02.txt", "再别康桥");//将字符串内容写入指定的文件，若文件存在就重写；若不存在就创建File.WriteAllLines("TestFile03.txt", new string[] { "断桥残雪", "有何不何", "星座书上" });//将字符串数组写入指定的文件，若文件存在就重写；若不存在就创建var byteDatas = File.ReadAllBytes("head.jpg");//读取字节数据File.WriteAllBytes("head02.png", byteDatas);//往指定路径的文件中写入字节数据Console.ReadKey();}}
}

using System.Text.RegularExpressions;namespace _002正则表达式
{public class Program{static void Main(string[] args){using (FileStream fileStream = new FileStream("TextFile2.txt", FileMode.Open)){using (StreamReader sr = new StreamReader(fileStream)){string str = "";while ( (str= sr.ReadLine())!= null){Console.WriteLine(str);}}}Console.ReadKey();}}
}

using System.Text.RegularExpressions;namespace _002正则表达式
{public class Program{static void Main(string[] args){using (FileStream fileStream = new FileStream("TextFile2.txt", FileMode.Append)){using (StreamWriter sr = new StreamWriter(fileStream)){sr.WriteLine("有何不可");sr.WriteLine("素颜");}}Console.ReadKey();}}
}

using System.Diagnostics;namespace StopWatch练习
{public class Program{       static void Main(string[] args){Stopwatch stopwatch = new Stopwatch();///第一次计时stopwatch.Start();//启动StopWatchConsole.WriteLine("计时器的运行状态："+stopwatch.IsRunning);//查看StopWtch的运行状态Thread.Sleep(5555);stopwatch.Stop();//停止StopWtchConsole.WriteLine("使用时分秒来输出时间格式："+stopwatch.Elapsed);//使用时分秒来输出Console.WriteLine("使用毫秒来输出："+stopwatch.ElapsedMilliseconds);// 使用毫秒来输出Console.WriteLine("计时器的运行状态：" + stopwatch.IsRunning);///第二次计时stopwatch.Start();Thread.Sleep(1000);stopwatch.Stop();Console.WriteLine("使用毫秒来输出："+stopwatch.ElapsedMilliseconds);///第三次计时stopwatch.Restart();//清空前面的时间并重新启动计时stopwatch.Start();Thread.Sleep(3000);stopwatch.Stop();Console.WriteLine("使用毫秒来输出：" +stopwatch.ElapsedMilliseconds);Console.ReadKey();}}
}

计时器的运行状态：True
使用时分秒来输出时间格式：00:00:05.5710477
使用毫秒来输出：5571
计时器的运行状态：False
使用毫秒来输出：6585
使用毫秒来输出：3014

using System.Collections.Concurrent;
using System.Runtime.CompilerServices;namespace prop
{public class Program{static async void Main(string[] args){// 请在此处写代码，调用 Foo 函数内的输出代码}private static void Foo(){try{while (true){}}finally{Console.WriteLine("尝试调用 Foo 函数执行这一句代码");}}}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;namespace ConsoleApp4
{using System.Collections.Concurrent;using System.Runtime.CompilerServices;using System.Threading;namespace prop{public class Program{static void Main(string[] args){// 请在此处写代码，调用 Foo 函数内的输出代码var thread = new Thread(() =>{Foo();});thread.Start();Task.Delay(1000).Wait();thread.Abort();//注意，在 dotnet core 不支持 Abort 方法Console.ReadLine();}private static void Foo(){try{while (true){}}finally{Console.WriteLine("尝试调用 Foo 函数执行这一句代码");}}}}
}

using System;
using System.Threading;class Test
{public static void Main(){Thread newThread = new Thread(new ThreadStart(TestMethod));newThread.Start();Thread.Sleep(1000);Console.WriteLine("Main aborting new thread.");newThread.Abort("Information from Main.");//强制中止newThread线程newThread.Join();//等待newThread线程执行完Console.WriteLine("New thread terminated - Main exiting.");Console.ReadKey();}static void TestMethod(){try{while (true){Console.WriteLine("New thread running.");Thread.Sleep(1000);}}catch (ThreadAbortException abortException){Console.WriteLine((string)abortException.ExceptionState);}finally{Console.WriteLine("Do somthing else in funally{}.");}Console.WriteLine("Do somthing else here.");}
}

New thread running.
Main aborting new thread.
Information from Main.
Do somthing else in funally{}.
New thread terminated - Main exiting.

using System;
using System.Threading;class Test
{public static void Main(){Thread newThread = new Thread(new ThreadStart(TestMethod));newThread.Start();Thread.Sleep(1000);Console.WriteLine("Main aborting new thread.");newThread.Abort("Information from Main.");//强制中止newThread线程newThread.Join();//等待newThread线程执行完Console.WriteLine("New thread terminated - Main exiting.");Console.ReadKey();}static void TestMethod(){try{while (true){Console.WriteLine("New thread running.");Thread.Sleep(1000);}}catch (ThreadAbortException abortException){Console.WriteLine((string)abortException.ExceptionState);Thread.ResetAbort();}finally{Console.WriteLine("Do somthing else in funally{}.");}Console.WriteLine("Do somthing else here.");}
}

New thread running.
Main aborting new thread.
Information from Main.
Do somthing else in funally{}.
Do somthing else here.
New thread terminated - Main exiting.

using System;
using System.Linq;
using System.Threading;class Test
{public static void Main(){Console.WriteLine(First("spider man")); Console.ReadKey();}public static string First(string input){if (string.IsNullOrEmpty(input)){throw new ArgumentNullException("输入字符串为空");}return input.First().ToString().ToUpper()+input.Substring(1);}
}

Spider man

class Test
{public static void Main(){var str = "123";if (int.TryParse(str, out var _)){}Console.ReadKey();}
}

using System;
using System.Linq;
using System.Threading;class Test
{public static void Main(){int? numb = null;numb = null;Console.WriteLine(numb);Console.ReadKey();}
}

for (int i = 0; i < n; i++)
{str += i.ToString();
}

    private readonly object _locker=new object();private void LockTest(){lock(_locker){}}

    [MethodImpl(MethodImplOptions.Synchronized)]///此特性表明，LockTest方法同一时刻只能被一个线程访问private void LockTest(){}

 class Program{static void Main(string[] args){var program = new Program();var autoResetEvent = new AutoResetEvent(false);var manualResetEvent = new ManualResetEvent(false);var task1 = Task.Run(() =>{lock (program){// 用于让 task1 执行到这里才让 task2 执行autoResetEvent.Set();// 用于等待 task2 执行完成manualResetEvent.WaitOne();}});var task2 = Task.Run(() =>{// 用于等待 task1 执行autoResetEvent.WaitOne();// 调用禁止冲入的方法program.F1();// 如果上面代码调用返回，那么让 tas1 继续执行manualResetEvent.Set();});Task.WaitAll(task1, task2);}[MethodImpl(MethodImplOptions.Synchronized)]private void F1(){Console.WriteLine("执行逻辑");}}

            Task.Run(() =>{var foo = 2;});Task.Factory.StartNew(() =>{var foo = 2;});

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;class Test
{private static async void SeenereKousa(){Console.WriteLine("开始 线程" + Thread.CurrentThread.ManagedThreadId);await Task.Run(() =>{Console.WriteLine("进入 线程" + Thread.CurrentThread.ManagedThreadId);});Console.WriteLine("退出 线程" + Thread.CurrentThread.ManagedThreadId);}static void Main(){SeenereKousa();Console.ReadKey();}}

开始 线程1
进入 线程3
退出 线程3

private static async void SeenereKousa(){Console.WriteLine("开始 线程"+Thread.CurrentThread.ManagedThreadId);await Task.Run(() =>{Console.WriteLine("进入 线程" + Thread.CurrentThread.ManagedThreadId);Console.WriteLine("退出 线程"+Thread.CurrentThread.ManagedThreadId);});}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;class Test
{private static async void SeenereKousa(){Console.WriteLine("开始 线程" + Thread.CurrentThread.ManagedThreadId);var t = Task.Run(() =>{Console.WriteLine("进入 线程" + Thread.CurrentThread.ManagedThreadId);});Task.WaitAll(t);Console.WriteLine("退出 线程" + Thread.CurrentThread.ManagedThreadId);}static void Main(){SeenereKousa();Console.ReadKey();}}

开始 线程1
进入 线程3
退出 线程1

        Task.Factory.StartNew(() =>{for (int i = 0; i < 100; i++){var foo = 2;}Console.WriteLine("进行 线程" + Thread.CurrentThread.ManagedThreadId);}, TaskCreationOptions.LongRunning);Console.ReadKey();

Task.Factory.StartNew(foo, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;class Test
{static void Main(){var uri1 = new Uri("https://blog.XXX.com/post/123");var uri2 = "/api/12";if (Uri.TryCreate(uri1, uri2, out var absoluteUrl)){// 拼接成功，在这里就可以使用 absoluteUrl 拼接后的绝对路径Console.WriteLine(absoluteUrl);}Console.ReadKey();}}

https://blog.xxx.com/api/12

class Test
{static void Main(){int value = 5;var result= Convert.ToString(value, 2);Console.WriteLine(result);Console.ReadKey();}
}

101