C#全面指南 第一章 3 变量和类型

1 变量

通常我们要在程序中存储一些信息，例如在一个五子棋游戏程序中，玩家每次走棋时都要存储棋子在棋盘上的横纵坐标。

棋盘的横坐标可以命名为x,纵坐标可以命名为y,当前执子的玩家可以命名为currentPlayer。
首先我们已经知道了五子棋程序需要存储什么值，那么这些值存储在什么地方哪？这些地方存储的又是何种类型的值哪？

在前面的示例中我们采取的策略都是声明一个变量，声明变量时用一个类型的关键字来说明变量的类型信息，用一个自定义的标识符来为变量的值命名。例如:

int x=3;
string currentPlayer="Player 1";

int是关键字，表示32位有符号整数类型。x是程序员自定义的标识符，表示棋盘落子点的横坐标，值为3。这个语句告诉程序，在内存中找一个存储位置，把这个存储位置的名称标记为x,并把值（这里是整数值3）复制到该位置。

string是关键字，表示字符串类型。currentPlayer是程序员自定义的标识符，表示当前执子玩家，值为Player 1。这个语句告诉程序，在内存中找一个存储位置，把这个存储位置的名称标记为currentPlayer,并把值（这里是字符串值Player 1）复制到该位置。

当我们声明一个变量时，系统会为该变量分配一段内存空间来存储其值。在程序执行期间，任何对该变量的操作都是对这段内存空间的读取或写入。由于变量的值可以随时改变，因此它们被称为“变量”。

注意：
string类型的数据，是不可修改的。例如：

无法将字符串"Hello World.“改成"Hello C++”。也就是说，不能修改变量最初引用的数据，只能重新赋值，让它指向内存中的新位置。

变量currentPlayer的值为Player 1，数据类型是string，那么这个变量的存储位置如何获取哪？下面我们了解一下变量的地址。

建议：

在C#中，指针的使用是受到限制的，并且必须启用“不安全代码”选项才能使用。因此，为了查找变量的地址，我们需要在代码中使用unsafe块并声明一个指针变量，然后通过&运算符获取变量的地址。

使用指针需要启用"不安全代码"选项。以下是在Visual Studio2022中启用unsafe选项的步骤：

1. 打开项目。

2. 右键点击项目名称，选择属性。

3. 选择"生成(B)"选项卡。

4. 找到"常规"选项，在其中勾选允许使用"unsafe"关键字编译的代码选项。

unsafe
{
   string currentPlayer="Player 1"; 
    string* ptr = &currentPlayer; // 获取currentPlayer变量的地址
    Console.WriteLine("currentPlayer的值为：{0}", currentPlayer);
    Console.WriteLine("currentPlayer的地址为：{0}", (int)ptr); // 将指针转换为int类型并输出
}

在上面的代码中，我们首先将代码放入了一个unsafe块中，并定义了一个字符串变量currentPlayer，并对其赋值为Player1。接下来我们使用一个字符串的指针变量ptr来获取currentPlayer变量的地址，最后将指针转换为int类型并输出它的值，即可获得currentPlayer变量的地址。

在C#中使用指针需要格外小心，因为指针可以直接修改内存中的数据，如果使用不当会造成程序崩溃或者数据损坏等问题。因此，在使用指针时一定要确保自己已经完全理解了指针的原理，并进行充分的测试和验证。

大多数情况下建议尽量使用安全的编程方式，避免使用指针。只有在特殊情况下需要进行高级操作才考虑使用指针，且需要格外小心。

1.1 变量的声明

在 C# 中，变量声明是为了告诉编译器变量的名称和类型。

上面示例中string currentPlayer; 语句是一则变量声明，它声明名为currentPlayer的string变量，并为currentPlayer变量分配了一块内存来作为存储容器。微软提倡C#使用有一定含义的变量名。如果变量表示游戏玩家，应将其命名为current_Player或currentPlayer，而不要将其命名为p或c。C#命名规则在前文中提过，可自行查阅。

可在同一条语句中声明多个变量，但只允许指定一次数据类型，然后用逗号分隔不同标识符。例如:

string currentPlayer,input;

变量声明时为变量名currentPlayer和input关联了一个string类型，类型和变量名关联后，类型不可更改。

变量为什么要声明？

有一些早期编程语言使用变量之前不用事先声明，这种做法看似方便程序员操作，实则后患无穷。例如：

currentPlayer="Player 1"
...
currentplayer="Player 2"
...

上例中把currentPlayer错误拼写成currentplayer(P错写成了p)以至于currentPlayer没有被赋新值，而是定义了一个新变量currentplayer。因为没有违反这种语言的任何规则，所以这种错误极难发现。在C#语言中，由于currentplayer没有事先声明，所以编译器会报错，避免了发生难以查找的错误。

1.2 变量的初始化

变量的初始化也可以简单理解成为变量第一次赋值。当声明string currentPlayer变量之后，可以使用=操作符为变量赋值。操作符是一种特殊符号，标识了代码要执行的操作。值要放在=操作符右侧。例如：

int x=3;
string currentPlayer;
currentPlayer="Player 1";
int x;
int y;
x=y=3; //看起来很怪异的赋值方式

我们可以为变量在声明时赋值，也可以用另外一条语句为变量赋值。同时C#也支持连续使用运算符赋值这种看似奇怪的赋值方式，赋值将从右向左进行。

1.3 使用变量

赋值语句将一个值存储进一块内存单元中，变量名标识了这块内存单元，因此使用变量名就是使用这个值。例如：

sstring currentPlayer;
currentPlayer = "AI";
Console.WriteLine(currentPlayer);
currentPlayer = "Player 1";
Console.WriteLine("{0}",currentPlayer);
currentPlayer = "Player 2";
Console.WriteLine($"{currentPlayer}");

2 类型

类型是一个蓝图，是一个模板。C#程序就是由类型声明组成的，所有值都是类型的实例。数据类型用于指定变量可以存储的数据类型。

C#预定义了几种简单的类型，它们是其他类型的基础。

2.1 预定义类型

C#内置了预定义类型，下面是一些内置的基本数据类型和其对应的常用取值范围：

类型	描述	取值范围
sbyte	8 位有符号整数	-128 到 127
byte	8 位无符号整数	0 到 255
short	16 位有符号整数	-32768 到 32767 之间的任意值。
ushort	16 位无符号整数	0 到 65535 之间的任意值。
int	32 位有符号整数	大约 -2 147 483 648 到 2 147 483 647之间的任意值。
uint	32 位无符号整数	大约 0 到 4 294 967 295之间的任意值。
long	64 位有符号整数	大约 -9 233 372 036 854 775 808 到 9 233 372 036 854 775 807 之间的任意值。
ulong	64 位无符号整数	大约 0 到 18 446 744 073 709 551 615之间的任意值。
float	32 位单精度浮点数	大约 ±1.5 x 10^-45 到 ±​​3.4 x ​​10^38​ 的任意小数值。
double	64 位双精度浮点数	大约 ±5 x 10^-324 to ±1.7 x 10^308 的任意小数值。
decimal	128 位精度的十进制浮点数	大约 ±1.0 x 10^-28 到 ±7.9 x 10^28 之间的任意小数值。
char	16 位 Unicode 字符	Unicode 字符集中任意一个字符
string	字符串类型	可以存储任意长度的文本数据。
bool	布尔型	true 或 false
object	对象类型	任意类型的值。
dynamic	动态类型	任意类型的值。

由于整数类型（int、long等）是有限的，当对一个已经达到最大值或最小值的整数进行运算时，就可能会发生数据溢出问题。数据溢出问题指的是一个变量存储的数值超出了其数据类型定义的上下限范围，从而导致计算错误。

例如：

int x = int.MaxValue;
int y = 1;
int z = x + y;
Console.WriteLine(c); // 输出结果为-2147483648

上面代码中，定义了一个变量x，并将其赋值为int类型的最大值。然后定义一个变量y，并将其赋值为1。最后将x和y相加，并将结果赋值给变量z。由于x已经达到了int类型的最大值，因此在x+y时发生了数据溢出，导致结果错误。

由于浮点数（float和double类型）采用二进制表示法，导致在进行数值运算时可能会出现精度丢失的问题。这是因为在二进制下，一些小数无法被准确表示，从而导致计算结果与预期不同。

例如：

double x = 0.1;
double y = 0.2;
double z = x + y;
Console.WriteLine(z); // 输出结果为0.30000000000000004

上面代码中，定义了两个浮点型变量x和y，分别赋值为0.1和0.2。然后将它们相加，并将结果赋值给另一个浮点型变量z。最后输出变量z的值，发现输出结果并不是我们预期的0.3，而是0.30000000000000004。

为了避免精度丢失的问题，可以使用decimal类型来进行数值运算。decimal类型采用十进制表示法，能够准确表示较小的小数，从而避免精度丢失的问题。例如：

decimal x = 0.1m;
decimal y = 0.2m;
decimal z = x + y;
Console.WriteLine(z); // 输出结果为0.3

上面代码中，使用decimal类型定义了三个变量x、y和z，并进行了数值运算。最后输出变量z的值，发现输出结果与预期一致。

decimal类型的计算速度相对较慢，因此应该根据实际情况选择合适的数值类型。如果需要进行高精度计算，可以考虑使用第三方库（如BigInteger）来进行处理。

在C#中，bool、char和string分别表示布尔型、字符型和字符串类型。

bool类型表示布尔型，只有true和false两个取值。它常用于条件语句和循环语句中，表示一个逻辑判断的结果。

char类型表示字符型，能够表示Unicode编码中的所有字符。它可以直接用单引号（’）来表示一个字符，也可以使用转义字符表示特殊字符。例如：

char ch1 = 'A';
char ch2 = '\u0061'; // 表示小写字母a
char ch3 = '\n'; // 表示换行符
Console.WriteLine(ch1); // 输出结果为A
Console.WriteLine(ch2); // 输出结果为a
Console.WriteLine(ch3); // 输出结果为换行符

上面代码中，定义了三个char类型的变量ch1、ch2和ch3，并分别赋值为’A’、’\u0061’和’\n’。然后使用Console.WriteLine方法输出变量的值。

string类型表示字符串型，是一个不可变的对象，可以存储任意长度的字符序列。它可以用双引号（"）或@符号来表示一个字符串，支持字符串连接、比较、查找等操作。例如：

string str1 = "Hello";
string str2 = "World";
string str3 = str1 + " " + str2;
Console.WriteLine(str3); // 输出结果为Hello World
Console.WriteLine(str3.Length); // 输出结果为11
Console.WriteLine(str3.StartsWith("Hello")); // 输出结果为True
Console.WriteLine(str3.IndexOf("World")); // 输出结果为6

上面代码中，定义了三个string类型的变量str1、str2和str3，并使用+运算符将它们连接成一个字符串。然后使用Length属性获取str3的长度，使用StartsWith方法判断str3是否以"Hello"开头，使用IndexOf方法查找"World"在str3中的位置。

由于string类型是不可变的，因此在进行大量操作时会产生大量的临时对象，从而导致性能问题。因此，为了提高性能，应该尽量避免创建过多的临时对象，使用StringBuilder类来处理大量的字符串拼接操作。

Unicode编码：

Unicode编码是一种用于表示字符的标准编码方式，它使用数字来表示所有的字符，包括ASCII字符和非ASCII字符。Unicode编码最初是由Unicode Consortium组织开发的，它包含了全世界所有已知的字符集，并提供了唯一的编号。

Unicode编码对于不同的字符可以使用不同的位数来表示，其中最常见的是两个字节（16位）或四个字节（32位）。每个字符都有一个唯一的编号，称为代码点。例如，汉字“中”的代码点是U+4E2D，即十进制的20013。

Unicode编码的目标是实现全球化、多语言环境下的字符表示，以及应用程序之间的字符交换。在计算机领域，Unicode编码经常被用于文本处理、网页设计、操作系统和软件开发等方面。

在C#中，char类型可以表示Unicode编码中的所有字符，而字符串类型则是由char类型组成的序列。因此，在进行字符处理时，可以使用char类型和字符串类型来表示和操作Unicode编码。同时，C#还提供了一些方法和类来处理Unicode编码，如Encoding类、StringInfo类等。

除了C#，Unicode编码在计算机科学和信息技术领域中广泛使用。例如，在操作系统中，Unicode编码被用于文件名、目录名以及各种文本输入和输出设备的驱动程序中。在Web开发中，Unicode编码被用于网页设计、字符集转换和国际化支持等方面。在数据库中，Unicode编码被用于存储和处理包含多语言字符的数据。

虽然Unicode编码可以表示所有的字符，但它并不是唯一的字符编码方式。在实际应用中，可能会出现不同的字符编码方式之间的转换和兼容性问题。为了避免这些问题，应该根据实际情况选择合适的编码方式，并遵循相关规范和标准，以确保数据的正确性和可移植性。

2.2 用户定义类型

在 C# 中，程序员还可以创建自己的类型，下面表格列出了常见的用户定义类型和描述：

类型	描述
Class	类，用于创建对象实例，并封装数据和行为
Struct	结构体，也可以用于封装数据，但通常比类更轻量级
Enum	枚举类型，用于表示一组相关的常量
Delegate	委托类型，用于封装方法并让其像对象一样传递，常用于事件处理等场景
Interface	接口类型，用于定义一组方法和属性，供其他类型实现
Array	数组类型，用于存储同种数据类型的元素
List<T>	列表类型，用于存储元素集合，并提供了一些常用的操作方法
Dictionary<TKey, TValue>	字典类型，用于存储键值对，并提供了一些常用的操作方法

2.3 类型转换

C# 中的数据类型转换是将一个数据类型的值转换为另一个数据类型的过程。下面介绍一些常见的数据类型转换：

1. 显式转换（强制类型转换）：通过强制转换实现，使用强制转换时需要在源类型前加上括号，并指定目标类型。例如：

int x = 3;
double y = (double)a;

2. 隐式转换（自动类型转换）：通过系统自动转换实现，不需要显式地调用任何转换函数或运算符。例如：

int x = 3;
float y = a;

3. Parse 方法：将字符串转换为其他类型，例如将字符串转换为整数类型：

string str = "123";
int number = int.Parse(str);

4. Convert 类型转换方法：Convert 类型转换方法允许从bool、char、sbyte、short、int、long、ushort、uint、ulong、float、double、decimal、DateTime和string转换到这些类型中的任何一种。

例如：

string str = "123";
int num = Convert.ToInt32(str);

5. dynamic类型

dynamic类型是一种动态类型，可以代表任何类型的值，并在运行时进行绑定。使用dynamic类型时，可以不用考虑类型的匹配问题，从而简化代码。例如：

dynamic obj = 3;
obj = "Player 1";

上面代码中，将一个int类型的值赋值给一个dynamic类型的变量obj，然后将其修改为字符串类型的值"hello"。

在 C# 中，变量类型分为静态类型和动态类型。静态类型的变量在声明时需要指定其数据类型，并且在编译时就确定了其数据类型，因此不能改变其类型。而动态类型的变量使用 dynamic 关键字声明，它的数据类型是在运行时确定的，可以根据需要随时改变其类型。

使用 dynamic 类型的变量可以实现更加灵活的编程，因为它可以在运行时根据需要改变类型，这对于某些特定场景非常有用。比如，当需要处理多种不同类型的数据时，使用 dynamic 可以避免繁琐的类型转换操作，使代码更加简洁易懂。

但是，dynamic 类型的变量也存在一些风险和限制。由于其类型是在运行时确定的，因此编译器无法检查其类型是否正确，可能会导致运行时错误。此外，由于动态类型的变量需要在运行时进行类型推断和转换，所以它的性能可能会受到影响，尤其是在大规模数据处理时。因此，在使用 dynamic 类型时需要权衡其优缺点，谨慎考虑。

6. var关键字

var关键字是一种隐式类型声明方式，可以使编译器根据变量的初始化值自动推断变量的类型。例如：

var x = 3;
var currentPlayer = "Player 1";

上面代码中，使用var关键字分别定义了一个int类型的变量x和一个string类型的变量currentPlayer。由于变量的初始化值已经确定，所以编译器可以自动推断变量的类型。在使用var关键字时，变量的类型只能在初始化时推断出来，不能在后续赋值中改变类型。

7. checked和unchecked

checked和unchecked是两种控制整数溢出检查的关键字。默认情况下，C#会对整数进行溢出检查，如果溢出则会抛出异常。使用checked关键字时，可以显式地开启整数溢出检查；使用unchecked关键字时，则可以关闭整数溢出检查。例如：

int x = int.MaxValue;
checked
{
    x++; // 抛出OverflowException异常
}

unchecked
{
    x++; // 不进行溢出检查,输出结果为-2147483648
}

使用checked关键字会带来一定的性能损失，因此应该根据实际情况选择合适的数据类型和操作方式。如果需要进行高精度计算，可以考虑使用第三方库（如BigInteger）来进行处理。C# 中某些类型之间的转换可能会导致精度丢失或者数据溢出，因此在进行类型转换时需要格外小心。

2.4 常用类型

​​以下是一些常用的类型。开发人员可以根据需要阅览，选择合适的类型来实现其业务逻辑。这些类型可以帮助开发人员更快、更有效地编写代码，提高代码的质量和性能。

基本数据类型

1. bool：布尔型，只能存储 true 或 false。

2. byte：8 位无符号整数，可以存储 0 到 255 之间的值。

3. sbyte：8 位有符号整数，可以存储 -128 到 127 之间的值。

4. char：16 位 Unicode 字符，可以存储Unicode 字符集中任意一个字符

5. decimal：128 位精度的十进制浮点数，可以储存大约 ±1.0 x 10^-28 到 ±7.9 x 10^28 之间的任意小数值。

6. double：64 位双精度浮点数，可以存储大约 ±5 x 10^-324 to ±1.7 x 10^308 的任意小数值。

7. float：32 位单精度浮点数，可以存储大约 ±1.5 x 10^-45 到 ±​​3.4 x ​​10^38​ 的任意小数值。

8. int：32 位有符号整数，可以存储大约-2 147 483 648 到 2 147 483 647之间的值。

9. uint：32 位无符号整数，可以存储 0 到大约 4 294 967 295 亿之间的值。

10. long：64 位有符号整数，可以存储大约 -9 233 372 036 854 775 808 到 9 233 372 036 854 775 807 之间的值。

11. ulong：64 位无符号整数，大约 0 到 18 446 744 073 709 551 615之间的值。

12. short：16 位有符号整数，可以存储 -32768 到 32767 之间的值。

13. ushort：16 位无符号整数，可以存储 0 到 65535 之间的值。

14. string：字符串类型，可以存储任意长度的文本数据。

高级数据类型

15. object：对象类型，可以存储任意类型的值。

16. dynamic：动态类型，用于在运行时才确定其类型。

17. void：空类型，表示方法没有返回值。

18. IntPtr：整型指针类型，用于表示指向内存中某个地址的指针。

19. UIntPtr：无符号整型指针类型。

20. Nullable<T>：可空值类型，用于表示一个值类型可以为 null 值。

集合类型

21. Array：数组类型，用于存储同种数据类型的元素。

22. List<T>：动态数组类型，用于存储元素集合，并提供了一些常用的操作方法。

23. Dictionary<TKey, TValue>：字典类型，用于存储键值对，并提供了一些常用的操作方法。

24. HashSet<T>：哈希集合类型，用于存储不重复的元素集合。

25. Queue<T>：队列类型，用于实现先进先出（FIFO）的数据结构。

26. Stack<T>：栈类型，用于实现后进先出（LIFO）的数据结构。

27. LinkedList<T>：链表类型，用于实现动态的双向链表。

28. SortedSet<T>：有序集合类型，用于存储不重复的元素，并按照自然顺序排序。

29. ConcurrentDictionary<TKey, TValue>：线程安全的字典类型。

30. ConcurrentBag<T>：线程安全的无序集合类型。

31. ConcurrentQueue<T>：线程安全的队列类型。

32. ConcurrentStack<T>：线程安全的栈类型。

其他类型

33. DateTime：表示日期和时间。

34. TimeSpan：表示时间间隔。

35. Guid：表示全局唯一标识符。

36. DBNull：表示数据库中的空值。

37. Delegate：委托类型，用于封装方法并让其像对象一样传递，常用于事件处理等场景。

38. Enum：枚举类型，用于表示一组相关的常量。

39. ValueType：值类型，是所有值类型的基类。

40. Nullable：可空类型，使值类型可以为 null。

41. Tuple：元组类型，用于存储一组值，可以具有不同的类型。

42. Task：任务类型，用于异步操作和并发编程。

43. Action 和 Func：委托类型，用于封装方法并让其像对象一样传递，常用于事件处理等场景。

44. Exception：异常类型，用于表示程序运行时出现的错误。

45. StreamReader 和 StreamWriter：流读取器和写入器类型，用于以文本形式读写文件。

46. FileStream：文件流类型，用于以二进制形式读写文件。

47. DirectoryInfo 和 FileInfo：目录和文件信息类型，用于管理文件系统中的目录和文件。

48. Regex：正则表达式类型，用于在文本中搜索匹配特定模式的字符序列。

49. HttpClient：HTTP 客户端类型，用于发送 HTTP 请求和接收响应。

50. ILogger：日志记录器类型，用于在应用程序中记录日志信息。

继续补充 C# 的预定义类型：

51. Uri：表示一个统一资源标识符 (URI)，用于处理 URL 和分布式计算中的其他标识符。

52. Version：表示程序集、操作系统或其他实例的版本号。

53. IComparable：定义可排序对象的比较方法。

54. IEquatable：提供确定两个对象是否相等的方法。

55. Attribute：表示元数据特性，可以用于为程序元素添加额外的信息。

56. MarshalByRefObject：提供基于远程处理的对象访问和生存期控制。

57. Activator：提供创建对象、获取类型信息、创建代理以及执行方法的方法。

58. Convert：提供将一种类型的值转换为另一种类型的静态方法。

59. Math：提供数学运算方法，如三角函数、幂函数和对数函数等。

60. Random：生成伪随机数的类。

61. Console：提供与命令行窗口交互的方法。

62. Environment：提供访问环境变量、命令行参数和操作系统信息的方法。

63. System.Diagnostics：提供用于代码诊断和调试的类和接口。

64. System.IO：提供文件和文件夹操作的类和接口。

65. System.Threading：提供多线程编程的类和接口。

66. System.Net：提供网络编程的类和接口。

67. System.Xml：提供 XML 编程的类和接口。

68. System.Text：提供字符串编码、解码和转换的类和接口。

69. System.Linq：提供查询和操作集合类型的方法。

70. System.Reflection：提供访问类型、成员和程序集的信息的类和接口。

71. System.Runtime.Serialization：提供对象序列化和反序列化的类和接口。

72. System.Security：提供安全编程的类和接口。

73. System.Collections.Concurrent：提供并发编程的集合类型。

74. System.ComponentModel.DataAnnotations：提供数据验证属性和规则的类和接口。

75. System.Configuration：提供访问应用程序配置文件的类和接口。

76. System.Diagnostics.CodeAnalysis：提供静态代码分析的类和接口。

77. System.Threading.Tasks：提供异步编程和任务并行性的类和接口。

78. System.Web 和 System.Web.Mvc：提供 Web 应用程序开发的类和接口。

79. System.Windows.Forms：提供 Windows 窗体应用程序开发的类和接口。

80. System.Xaml：提供 XAML 编程的类和接口。

81. System.Xml.Linq：提供 LINQ to XML 编程的类和接口。

82. System.Data：提供数据库编程的类和接口。

83. System.ServiceModel：提供 WCF 编程的类和接口。

84. System.Threading.Timer：提供定时器编程的类和接口。

85. System.Linq.Expressions：提供表达式编程的类和接口。

86. System.Runtime.CompilerServices：提供高级语言功能的类和接口。

87. System.Security.Cryptography：提供加密和解密算法的类和接口。

88. System.Runtime.InteropServices：提供与非托管代码交互的类和接口。

89. System.Net.Http：提供 HTTP 客户端和服务器的类和接口。

90. System.Diagnostics.Eventing：提供事件记录和追踪的类和接口。

91. System.IO.Compression：提供文件压缩和解压缩的类和接口。

92. System.Numerics：提供高精度数值计算的类和接口。

93. System.Resources：提供访问应用程序资源的类和接口。

94. System.Threading.Tasks.Dataflow：提供数据流编程的类和接口。

95. System.Diagnostics.Tracing：提供事件追踪的类和接口。

96. System.CodeDom：提供代码生成和编译的类和接口。

97. System.Drawing：提供图形编程的类和接口。

98. System.Windows.Media：提供界面设计和呈现的类和接口。

99. System.Management：提供管理操作系统和硬件资源的类和接口。

100. System.Web.Http：提供 Web API 编程的类和接口。

101. System.IdentityModel：提供安全和身份验证的类和接口。

102. System.Globalization：提供本地化和国际化功能的类和接口。

103. System.Runtime.Remoting：提供远程对象调用的类和接口。

104. System.Xml.Serialization：提供 XML 序列化和反序列化的类和接口。

105. System.DirectoryServices：提供与 Active Directory 相关的编程的类和接口。

106. System.Net.Mail：提供电子邮件发送和接收的类和接口。

107. System.Data.SqlClient：提供使用 SQL Server 数据库的类和接口。

108. System.Windows.Input：提供输入事件处理和处理程序的类和接口。

109. System.Diagnostics.Contracts：提供代码合同和断言功能的类和接口。

110. System.Runtime.Serialization.Formatters：提供二进制序列化和反序列化的类和接口。

111. System.AddIn：提供插件和扩展性的类和接口。

112. System.DirectoryServices.AccountManagement：提供与 Active Directory 帐户管理相关的编程的类和接口。

113. System.Transactions：提供分布式事务的类和接口。

114. System.Security.AccessControl：提供访问控制和权限管理相关的编程的类和接口。

115. System.ServiceModel.Web：提供 RESTful Web 应用程序开发的类和接口。

116. System.Runtime.CompilerServices.AsyncMethodBuilder：提供异步方法编写的类和接口。

117. System.Configuration.Install：提供安装和卸载应用程序的类和接口。

118. System.Net.NetworkInformation：提供网络信息查询和管理的类和接口。

119. System.IdentityModel.Tokens：提供令牌和身份验证相关的编程的类和接口。

120. System.Data.Odbc：提供使用 ODBC 数据源的类和接口。

这些预定义类型提供了丰富的功能和强大的工具，可以帮助开发人员构建高效的应用程序。无论是处理数据、网络编程、图形编程还是安全编程，都可以使用这些类型来实现。