在C#中，模式匹配是一种强大的特性，它允许你在表达式中检查和操作值的结构。自从C# 7.0引入以来，模式匹配主要通过两种形式实现：模式匹配的is表达式和switch表达式（从C# 8.0引入的switch表达式增强版）。
1. 模式匹配概述
1.1 定义与用途
模式匹配（Pattern Matching）是C# 语言中的一种强大的特性，它允许程序员在代码中以简洁且高效的方式对对象的类型和结构进行检查和处理。模式匹配的核心在于能够在运行时对对象进行类型检查，并且可以同时提取对象的值，从而简化代码逻辑并提高代码的可读性和可维护性。
在C#中，模式匹配主要通过is关键字和switch语句来实现。is关键字不仅可以用于传统的类型检查，还可以结合模式匹配来检查对象是否符合特定的模式。例如，通过is关键字可以检查一个对象是否是某个特定类型，并且可以同时提取该类型的特定属性或字段。这种能力使得代码更加简洁，避免了冗长的类型转换和条件判断。
模式匹配的用途广泛，它在处理复杂的对象结构、实现多态行为、简化条件逻辑等方面都发挥着重要作用。例如，在处理用户输入时，可以通过模式匹配快速判断输入的类型并进行相应的处理；在处理数据结构时，可以利用模式匹配提取数据中的关键信息，从而实现高效的逻辑处理。
随着C#语言的不断发展，模式匹配的功能也在不断增强。从C# 7.0引入模式匹配的初步支持，到C# 8.0进一步扩展了模式匹配的能力，模式匹配已经成为C#语言中不可或缺的一部分，为开发者提供了更加灵活和强大的编程工具。
2. 模式匹配的基本语法
2.1 is 关键字的使用
is关键字是C#中实现模式匹配的基础语法之一。在C# 7.0之前，is关键字主要用于简单的类型检查，例如判断一个对象是否是某个特定类型。然而，从C# 7.0开始，is关键字的功能得到了扩展，支持了模式匹配。
-
类型模式（Type Pattern）：这是最简单的模式匹配形式。通过
is关键字，可以判断一个对象是否是某个特定类型，并且可以将该对象的值赋给一个变量。例如，以下代码展示了如何使用类型模式：
-
if (obj is int number) { Console.WriteLine($"The number is {number}."); }在这个例子中，
obj is int number不仅检查obj是否是int类型，还将obj的值赋给变量number，使得在if语句块中可以直接使用number变量。 -
常量模式（Constant Pattern）：常量模式用于检查一个值是否等于某个常量值。例如：
-
if (obj is 42) { Console.WriteLine("The value is 42."); }在这个例子中，
obj is 42检查obj的值是否等于常量42。 -
属性模式（Property Pattern）：属性模式允许在模式匹配时检查对象的属性。例如：
-
if (person is { Name: "Alice", Age: 30 }) { Console.WriteLine("The person is Alice and she is 30 years old."); }在这个例子中，
person is { Name: "Alice", Age: 30 }检查person对象的Name属性是否等于"Alice"，并且Age属性是否等于30。 -
递归模式（Recursive Pattern）：递归模式允许在模式匹配中嵌套使用模式。例如：
-
if (shape is Circle { Radius: > 0 }) { Console.WriteLine("The shape is a circle with a positive radius."); }在这个例子中，
shape is Circle { Radius: > 0 }首先检查shape是否是Circle类型，然后检查Circle对象的Radius属性是否大于0。
2.2 when 子句的结合
when子句可以与is关键字结合使用，以在模式匹配时添加额外的条件。这使得模式匹配更加灵活和强大。例如：
if (obj is int number when (number > 0))
{
Console.WriteLine($"The number is positive: {number}.");
}
在这个例子中，obj is int number when (number > 0)不仅检查obj是否是int类型，还将obj的值赋给变量number，并且通过when子句进一步检查number是否大于0。只有当number大于0时，if语句块才会执行。
when子句可以用于is关键字和switch语句中，为模式匹配提供了更复杂的条件判断能力。例如：
switch (shape)
{
case Circle { Radius: > 0 } when (shape.Area > 100):
Console.WriteLine("The circle has a large area.");
break;
case Rectangle { Width: > 0, Height: > 0 } when (shape.Area > 50):
Console.WriteLine("The rectangle has a large area.");
break;
default:
Console.WriteLine("The shape is not recognized.");
break;
}
在这个例子中，switch语句结合了属性模式和when子句，分别对Circle和Rectangle对象的面积进行了额外的条件判断。
3. 模式匹配的类型
3.1 常量模式
常量模式是模式匹配中最简单的一种形式，它用于检查一个值是否等于某个常量值。在C#中，常量模式通常与is关键字结合使用，以实现对对象值的快速检查。这种模式在处理简单的类型检查和值比较时非常高效，能够显著简化代码逻辑。
例如，以下代码展示了如何使用常量模式来检查一个对象的值是否等于某个特定的常量值：
if (obj is 42)
{
Console.WriteLine("The value is 42.");
}
在这个例子中，obj is 42检查obj的值是否等于常量42。如果条件成立，代码块中的内容将被执行。
常量模式的一个重要特点是它可以直接对值进行比较，而不需要进行类型转换或复杂的逻辑判断。这使得代码更加简洁明了，同时也提高了代码的执行效率。在实际开发中，常量模式常用于处理用户输入、配置文件中的值检查等场景，能够快速判断输入值是否符合预期。
3.2 变量模式
变量模式是C# 8.0引入的一种新模式，它允许在模式匹配中声明一个新的变量，并将匹配的对象赋值给该变量。变量模式的核心在于能够在模式匹配的同时，直接对匹配的对象进行进一步的处理，而无需进行额外的赋值操作。
以下是一个使用变量模式的例子：
if (obj is var x)
{
Console.WriteLine($"The value is {x}.");
}
在这个例子中，obj is var x将obj的值赋给变量x，并且在if语句块中可以直接使用变量x。变量模式的一个显著特点是它不关心对象的类型，而是直接将对象赋值给一个变量，这使得变量模式在处理未知类型或动态类型时非常灵活。
变量模式的一个重要应用场景是处理动态类型或反射返回的对象。由于变量模式不依赖于具体的类型信息，它可以在不知道对象具体类型的情况下，直接对对象进行操作。这在处理JSON解析、XML解析等场景中非常有用，能够快速提取对象的值并进行进一步的处理。
3.3 类型模式
类型模式是模式匹配中最为常用的一种形式，它用于检查一个对象是否是某个特定类型，并且可以同时提取该类型的特定属性或字段。类型模式的核心在于能够在运行时对对象进行类型检查，并且在检查通过后直接对对象的属性或字段进行访问，从而简化代码逻辑并提高代码的可读性和可维护性。
以下是一个使用类型模式的例子：
if (obj is int number)
{
Console.WriteLine($"The number is {number}.");
}
在这个例子中，obj is int number不仅检查obj是否是int类型，还将obj的值赋给变量number，使得在if语句块中可以直接使用number变量。这种模式在处理复杂的对象结构时非常有用，能够快速提取对象的关键信息并进行处理。
类型模式的一个重要特点是它结合了类型检查和变量声明的功能，使得代码更加简洁。在实际开发中，类型模式常用于处理多态对象、复杂的数据结构等场景，能够显著简化代码逻辑并提高代码的可读性。例如，在处理一个包含多种类型对象的集合时，类型模式可以快速判断每个对象的类型，并提取相应的属性或字段，从而实现高效的逻辑处理。
4. 模式匹配在 switch 语句中的应用
4.1 switch 语句的模式匹配语法
在C# 8.0及更高版本中，switch语句得到了极大的增强，支持了模式匹配。这使得switch语句不仅能够基于值进行分支选择，还能够结合类型检查和属性匹配，从而实现更复杂的逻辑处理。
以下是switch语句中模式匹配的基本语法：
switch (expression)
{
case 类型模式 when (条件表达式):
// 代码块
break;
case 属性模式 when (条件表达式):
// 代码块
break;
case 常量模式:
// 代码块
break;
default:
// 默认代码块
break;
}
-
类型模式：在
case语句中，可以使用类型模式来检查表达式的类型。如果表达式匹配指定的类型，则执行相应的代码块。例如：
-
switch (obj) { case int number: Console.WriteLine($"The number is {number}."); break; case string text: Console.WriteLine($"The text is {text}."); break; default: Console.WriteLine("Unknown type."); break; } -
属性模式：属性模式允许在
case语句中检查对象的属性。如果对象的属性匹配指定的条件，则执行相应的代码块。例如： -
switch (person) { case { Name: "Alice", Age: 30 }: Console.WriteLine("The person is Alice and she is 30 years old."); break; case { Name: "Bob", Age: 25 }: Console.WriteLine("The person is Bob and he is 25 years old."); break; default: Console.WriteLine("Unknown person."); break; } -
常量模式：常量模式用于检查表达式的值是否等于某个常量值。如果表达式的值匹配指定的常量，则执行相应的代码块。例如：
-
switch (obj) { case 42: Console.WriteLine("The value is 42."); break; case "Hello": Console.WriteLine("The value is 'Hello'."); break; default: Console.WriteLine("Unknown value."); break; } -
when子句：when子句可以与case语句结合使用，以在模式匹配时添加额外的条件。这使得switch语句更加灵活和强大。例如：
-
switch (shape) { case Circle { Radius: > 0 } when (shape.Area > 100): Console.WriteLine("The circle has a large area."); break; case Rectangle { Width: > 0, Height: > 0 } when (shape.Area > 50): Console.WriteLine("The rectangle has a large area."); break; default: Console.WriteLine("The shape is not recognized."); break; }
4.2 模式匹配的案例分析
4.2.1 案例一：处理用户输入
假设我们需要处理用户输入的多种类型数据，例如整数、字符串和布尔值。通过switch语句结合模式匹配，可以简洁地实现这一需求。
object userInput = GetInputFromUser(); // 假设这是一个从用户获取输入的方法
switch (userInput)
{
case int number:
Console.WriteLine($"You entered a number: {number}");
break;
case string text:
Console.WriteLine($"You entered a text: {text}");
break;
case bool flag:
Console.WriteLine($"You entered a boolean value: {flag}");
break;
default:
Console.WriteLine("Unknown input type.");
break;
}
在这个案例中，switch语句结合类型模式，能够快速判断用户输入的类型，并执行相应的处理逻辑。
4.2.2 案例二：处理复杂对象
假设我们有一个Person类，包含Name、Age和Gender属性。我们需要根据这些属性进行不同的处理。通过switch语句结合属性模式，可以实现这一需求。
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public string Gender { get; set; }
}
Person person = GetPersonFromDatabase(); // 假设这是一个从数据库获取Person对象的方法
switch (person)
{
case { Name: "Alice", Age: 30, Gender: "Female" }:
Console.WriteLine("The person is Alice, 30 years old, and female.");
break;
case { Name: "Bob", Age: 25, Gender: "Male" }:
Console.WriteLine("The person is Bob, 25 years old, and male.");
break;
case { Age: < 18 }:
Console.WriteLine("The person is a minor.");
break;
default:
Console.WriteLine("Unknown person.");
break;
}
在这个案例中，switch语句结合属性模式，能够根据Person对象的多个属性进行复杂的条件判断，并执行相应的处理逻辑。
4.2.3 案例三：处理自定义类型
假设我们有一个Shape类及其派生类Circle和Rectangle，我们需要根据形状的类型和属性进行不同的处理。通过switch语句结合模式匹配，可以实现这一需求。
public abstract class Shape
{
public abstract double Area { get; }
}
public class Circle : Shape
{
public double Radius { get; set; }
public override double Area => Math.PI * Radius * Radius;
}
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public override double Area => Width * Height;
}
Shape shape = GetShapeFromUser(); // 假设这是一个从用户获取Shape对象的方法
switch (shape)
{
case Circle { Radius: > 0 } when (shape.Area > 100):
Console.WriteLine("The circle has a large area.");
break;
case Rectangle { Width: > 0, Height: > 0 } when (shape.Area > 50):
Console.WriteLine("The rectangle has a large area.");
break;
default:
Console.WriteLine("The shape is not recognized.");
break;
}
在这个案例中，switch语句结合类型模式和when子句，能够根据Shape对象的类型和属性进行复杂的条件判断，并执行相应的处理逻辑。
通过这些案例可以看出，switch语句结合模式匹配能够显著简化代码逻辑，提高代码的可读性和可维护性，同时提供了更强大的功能来处理复杂的场景。
5. 模式匹配与解构
5.1 解构的定义
解构（Deconstruction）是C#语言中的一种特性，它允许将一个对象或值拆解为多个变量。解构的主要目的是将一个复杂的数据结构分解为多个单独的变量，从而方便对这些变量进行操作。解构通常用于元组（Tuple）、自定义类型以及集合等场景，能够显著简化代码逻辑并提高代码的可读性。
例如，对于一个包含两个值的元组，可以通过解构将其拆解为两个单独的变量：
var tuple = (1, 2);
var (x, y) = tuple;
Console.WriteLine($"x = {x}, y = {y}"); // 输出：x = 1, y = 2
在自定义类型中，也可以通过实现Deconstruct方法来支持解构。例如：
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public void Deconstruct(out string name, out int age)
{
name = Name;
age = Age;
}
}
Person person = new Person { Name = "Alice", Age = 30 };
var (name, age) = person;
Console.WriteLine($"Name: {name}, Age: {age}"); // 输出：Name: Alice, Age: 30
解构的一个重要特点是它能够将一个复杂的数据结构分解为多个单独的变量，从而方便对这些变量进行操作。这在处理多个相关值时非常有用，能够显著简化代码逻辑并提高代码的可读性。
5.2 解构与模式匹配的结合
解构与模式匹配可以结合使用，进一步增强代码的灵活性和可读性。通过将解构与模式匹配结合，可以在模式匹配的过程中直接将对象的属性或字段解构为多个变量，从而简化代码逻辑并提高代码的可维护性。
例如，假设我们有一个Person类，包含Name和Age属性，并且我们希望在模式匹配时直接解构这些属性。可以通过以下方式实现：
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public void Deconstruct(out string name, out int age)
{
name = Name;
age = Age;
}
}
Person person = new Person { Name = "Alice", Age = 30 };
if (person is (string name, int age))
{
Console.WriteLine($"Name: {name}, Age: {age}"); // 输出：Name: Alice, Age: 30
}
在这个例子中，person is (string name, int age)不仅检查person是否是一个Person对象，还将Name和Age属性解构为name和age变量，使得在if语句块中可以直接使用这些变量。
解构与模式匹配的结合还可以用于更复杂的场景。例如，假设我们有一个Shape类及其派生类Circle和Rectangle，并且我们希望在模式匹配时直接解构这些类的属性。可以通过以下方式实现：
public abstract class Shape
{
public abstract double Area { get; }
}
public class Circle : Shape
{
public double Radius { get; set; }
public override double Area => Math.PI * Radius * Radius;
public void Deconstruct(out double radius)
{
radius = Radius;
}
}
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public override double Area => Width * Height;
public void Deconstruct(out double width, out double height)
{
width = Width;
height = Height;
}
}
Shape shape = new Circle { Radius = 5 };
if (shape is Circle (double radius))
{
Console.WriteLine($"Circle with radius: {radius}"); // 输出：Circle with radius: 5
}
else if (shape is Rectangle (double width, double height))
{
Console.WriteLine($"Rectangle with width: {width}, height: {height}");
}
在这个例子中，shape is Circle (double radius)不仅检查shape是否是一个Circle对象，还将Radius属性解构为radius变量；shape is Rectangle (double width, double height)不仅检查shape是否是一个Rectangle对象，还将Width和Height属性解构为width和height变量。这种结合方式使得代码更加简洁明了，同时也提高了代码的可维护性。
通过解构与模式匹配的结合，可以在模式匹配的过程中直接将对象的属性或字段解构为多个变量，从而进一步简化代码逻辑并提高代码的可读性和可维护性。这种结合方式在处理复杂对象和数据结构时非常有用，能够显著提高代码的灵活性和可读性。
6. 模式匹配的性能考量
6.1 性能优势
模式匹配在C#中的实现经过了精心设计，以确保其在运行时的高效性。以下是一些模式匹配的性能优势：
-
减少冗余类型检查：在传统的代码中，经常需要多次进行类型检查和转换，例如使用
is关键字进行类型判断，再通过强制类型转换来访问对象的属性。而模式匹配可以在一次操作中完成类型检查和变量声明，减少了不必要的类型检查和转换开销。例如，使用类型模式if (obj is int number)，不仅检查了obj是否为int类型，还直接将obj的值赋给变量number，避免了额外的类型转换。 -
优化的内部实现：C#编译器对模式匹配进行了优化处理。在编译阶段，编译器会将模式匹配的代码转换为高效的中间语言（IL）代码。例如，对于简单的类型模式匹配，编译器会生成直接的类型检查指令，而不是通过复杂的反射或运行时类型信息（RTTI）来判断类型，从而提高了运行时的性能。
-
减少临时变量的创建：在一些复杂的模式匹配场景中，如递归模式和属性模式，模式匹配可以在不创建额外临时变量的情况下直接访问对象的属性。这与传统的通过中间变量来传递和处理对象属性的方式相比，减少了内存分配和垃圾回收的开销。例如，
if (shape is Circle { Radius: > 0 })直接检查shape的Radius属性，而无需创建临时变量来存储shape的引用或属性值。
6.2 性能优化建议
尽管模式匹配本身已经具有较高的性能，但在实际开发中，仍然可以通过以下方式进一步优化模式匹配的性能：
-
避免过度使用复杂的模式匹配：虽然模式匹配功能强大，但在某些情况下，过度使用复杂的模式匹配可能会导致代码的可读性和性能下降。例如，当需要匹配的对象结构非常复杂，或者模式匹配的条件非常繁琐时，可以考虑将模式匹配与传统的条件判断语句结合使用，以提高代码的可读性和执行效率。例如，对于一个包含多个嵌套属性的对象，可以先通过简单的类型模式匹配来确定对象的类型，然后再使用传统的条件语句来进一步处理对象的属性。
-
合理使用
when子句：when子句虽然为模式匹配提供了更强大的条件判断能力，但过度使用when子句可能会增加代码的复杂性和运行时开销。在使用when子句时，应尽量确保条件表达式简单且高效。例如，避免在when子句中调用复杂的函数或进行大量的计算，而是尽量使用简单的变量比较或逻辑运算。 -
结合缓存机制优化重复模式匹配：如果在代码中需要对同一个对象进行多次模式匹配，可以考虑将模式匹配的结果缓存起来，以避免重复的模式匹配操作。例如，可以使用一个字典或其他数据结构来存储对象的类型信息或模式匹配的结果，在后续的模式匹配中直接从缓存中获取结果，从而提高性能。
7. 模式匹配的实践案例
7.1 简单数据类型匹配
在实际开发中，模式匹配常用于处理简单数据类型的匹配和转换。这种场景下，模式匹配能够显著简化代码逻辑，减少冗余的类型检查和转换操作。以下是一些具体的实践案例：
7.1.1 处理用户输入
假设我们需要处理用户输入的多种类型数据，例如整数、字符串和布尔值。通过switch语句结合模式匹配，可以简洁地实现这一需求。
object userInput = GetInputFromUser(); // 假设这是一个从用户获取输入的方法
switch (userInput)
{
case int number:
Console.WriteLine($"You entered a number: {number}");
break;
case string text:
Console.WriteLine($"You entered a text: {text}");
break;
case bool flag:
Console.WriteLine($"You entered a boolean value: {flag}");
break;
default:
Console.WriteLine("Unknown input type.");
break;
}
在这个案例中，switch语句结合类型模式，能够快速判断用户输入的类型，并执行相应的处理逻辑。通过模式匹配，代码更加简洁明了，减少了冗余的if-else判断。
7.1.2 数据类型转换
模式匹配还可以用于数据类型的转换和处理。例如，假设我们需要将一个对象转换为特定的类型，并进行相应的操作。
object data = GetData(); // 假设这是一个从外部获取数据的方法
if (data is int number)
{
Console.WriteLine($"The data is an integer: {number}");
}
else if (data is double value)
{
Console.WriteLine($"The data is a double: {value}");
}
else if (data is string text)
{
Console.WriteLine($"The data is a string: {text}");
}
else
{
Console.WriteLine("Unknown data type.");
}
在这个案例中，通过is关键字结合类型模式，可以直接将对象data转换为相应的类型，并在if语句块中直接使用转换后的变量。这种方式不仅简化了代码逻辑，还提高了代码的可读性和可维护性。
7.1.3 简化条件逻辑
模式匹配还可以用于简化复杂的条件逻辑。例如，假设我们需要根据一个对象的值进行不同的处理，传统的方式可能需要多个if-else嵌套，而使用模式匹配可以显著简化代码。
object result = GetResult(); // 假设这是一个从外部获取结果的方法
switch (result)
{
case 0:
Console.WriteLine("The result is zero.");
break;
case 1:
Console.WriteLine("The result is one.");
break;
case -1:
Console.WriteLine("The result is negative one.");
break;
default:
Console.WriteLine("The result is unknown.");
break;
}
在这个案例中，switch语句结合常量模式，能够快速判断result的值，并执行相应的处理逻辑。通过模式匹配，代码更加简洁明了，减少了冗余的条件判断。
7.2 复杂对象匹配
模式匹配在处理复杂对象时也非常强大，能够显著简化代码逻辑并提高代码的可读性。以下是一些具体的实践案例：
7.2.1 处理自定义对象
假设我们有一个Person类，包含Name、Age和Gender属性。我们需要根据这些属性进行不同的处理。通过switch语句结合属性模式，可以实现这一需求。
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public string Gender { get; set; }
}
Person person = GetPersonFromDatabase(); // 假设这是一个从数据库获取Person对象的方法
switch (person)
{
case { Name: "Alice", Age: 30, Gender: "Female" }:
Console.WriteLine("The person is Alice, 30 years old, and female.");
break;
case { Name: "Bob", Age: 25, Gender: "Male" }:
Console.WriteLine("The person is Bob, 25 years old, and male.");
break;
case { Age: < 18 }:
Console.WriteLine("The person is a minor.");
break;
default:
Console.WriteLine("Unknown person.");
break;
}
在这个案例中，switch语句结合属性模式，能够根据Person对象的多个属性进行复杂的条件判断，并执行相应的处理逻辑。通过模式匹配，代码更加简洁明了，减少了冗余的if-else判断。
7.2.2 处理继承关系
假设我们有一个Shape类及其派生类Circle和Rectangle，我们需要根据形状的类型和属性进行不同的处理。通过switch语句结合模式匹配，可以实现这一需求。
public abstract class Shape
{
public abstract double Area { get; }
}
public class Circle : Shape
{
public double Radius { get; set; }
public override double Area => Math.PI * Radius * Radius;
}
public class Rectangle : Shape
{
public double Width { get; set; }
public double Height { get; set; }
public override double Area => Width * Height;
}
Shape shape = GetShapeFromUser(); // 假设这是一个从用户获取Shape对象的方法
switch (shape)
{
case Circle { Radius: > 0 } when (shape.Area > 100):
Console.WriteLine("The circle has a large area.");
break;
case Rectangle { Width: > 0, Height: > 0 } when (shape.Area > 50):
Console.WriteLine("The rectangle has a large area.");
break;
default:
Console.WriteLine("The shape is not recognized.");
break;
}
在这个案例中，switch语句结合类型模式和when子句，能够根据Shape对象的类型和属性进行复杂的条件判断，并执行相应的处理逻辑。通过模式匹配，代码更加简洁明了，减少了冗余的类型检查和条件判断。
7.2.3 解构与模式匹配结合
假设我们有一个Person类，包含Name和Age属性，并且我们希望在模式匹配时直接解构这些属性。可以通过以下方式实现：
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
public void Deconstruct(out string name, out int age)
{
name = Name;
age = Age;
}
}
Person person = new Person { Name = "Alice", Age = 30 };
if (person is (string name, int age))
{
Console.WriteLine($"Name: {name}, Age: {age}"); // 输出：Name: Alice, Age: 30
}
在这个例子中，person is (string name, int age)不仅检查person是否是一个Person对象，还将Name和Age属性解构为name和age变量，使得在if语句块中可以直接使用这些变量。通过解构与模式匹配的结合，代码更加简洁明了，同时也提高了代码的可维护性。
通过这些实践案例可以看出，模式匹配在处理简单数据类型和复杂对象时都非常强大，能够显著简化代码逻辑，提高代码的可读性和可维护性。
扫一扫
1025
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
