C#基础知识

0 C#介绍

1. 定义与背景

   • C#（发音为C - sharp）是微软公司开发的一种高级编程语言。它是专门为构建在微软的.NET平台上运行的各种应用程序而设计的。在2000年左右推出，目的是结合当时编程语言的优点，如C++的强大功能和Java的简单性与安全性，来满足开发人员对高效、安全、面向对象编程的需求。

2. 语法结构

   • 基础语法规则
     • C#的代码以语句为基本单位，语句以分号“;”结尾。例如，Console.WriteLine("Hello");这一语句用于在控制台输出“Hello”，最后的分号是必须的。
     • 代码块通过花括号“{ }”来界定范围。比如在定义一个方法或者一个控制结构（如if - else语句）时，花括号内包含的是属于该结构的代码部分。
   • 变量与数据类型
     • C#是强类型语言，这意味着每个变量都必须有明确的类型声明。常见的数据类型有整数类型（如int，用于表示整数，如int num = 5;）、浮点类型（如float和double，用于表示带有小数的数字）、字符类型（char，如char letter = 'A';）和字符串类型（string，如string name = "John";）。
     • 变量的命名需要遵循一定的规则，通常以字母或下划线开头，后面可以跟字母、数字或下划线，并且区分大小写。

3. 面向对象特性

   • 类与对象
     • 类是C#中面向对象编程的核心概念。它是一种数据结构，用于封装数据成员（字段）和方法成员。例如，定义一个简单的“Person”类：

     class Person
     {
            
         public string Name;
         public int Age;
         public void SayHello()
         {
            
             Console.WriteLine($"我叫{
              Name}，今年{
              Age}岁。");
         }
     }
     

     • 对象是类的实例。可以通过new关键字来创建对象。例如，Person p = new Person(); p.Name = "Alice"; p.Age = 20; p.SayHello();，这里创建了一个“Person”类的对象p，设置了它的姓名和年龄属性，并调用了SayHello方法。
   • 继承与多态
     • 继承允许一个类（派生类）继承另一个类（基类）的属性和方法。例如，定义一个“Student”类继承自“Person”类：

     class Student : Person
     {
            
         public string School;
         public void Study()
         {
            
             Console.WriteLine($"{
              Name}在{
              School}学习。");
         }
     }
     

     • 多态是指不同类的对象对同一消息做出不同响应的能力。在C#中，可以通过方法重写来实现。例如，在基类中有一个虚方法，在派生类中重写这个方法，当通过基类引用调用这个方法时，会根据对象的实际类型（是基类对象还是派生类对象）来执行相应的方法。

4. 应用场景

   • 桌面应用开发
     • C#与Windows Forms或Windows Presentation Foundation（WPF）结合可以开发出功能丰富的桌面应用程序。Windows Forms提供了一种简单的方式来创建具有传统Windows风格的用户界面，而WPF则侧重于提供更灵活、更具视觉效果的界面设计，通过XAML（可扩展应用程序标记语言）和C#代码的结合来构建界面。
   • Web应用开发
     • 与ASP.NET技术配合，C#用于开发Web应用程序。ASP.NET提供了多种开发模式，如Web Forms和MVC（Model - View - Controller）。在MVC模式下，C#主要用于编写控制器（Controller）中的业务逻辑，处理用户请求并返回数据给视图（View）进行展示。
   • 游戏开发
     • 在游戏开发领域，C#与Unity游戏引擎配合紧密。Unity允许开发者使用C#编写游戏脚本，包括游戏角色的行为控制、场景切换、用户交互等各个方面的内容，能够开发出跨平台的2D和3D游戏。

1 基本语法

1.1. 变量、类型和方法名称

• C#是区分大小写的语言。这意味着变量名、类型名和方法名等标识符的大小写不同会被视为不同的实体。
• 例如，定义一个变量int myVariable;，如果在其他地方尝试访问myvariable（小写的v），编译器会认为这是一个未定义的标识符，从而产生错误。同样，对于类型，如string和String（在C#中，string是System.String类型的别名，它们是等价的，但要注意大小写一致），如果在代码中混淆使用，也会导致错误。对于方法名也是如此，MyMethod()和mymethod()是不同的方法名。

1.2. 关键字

• C#的关键字是固定的，并且也是区分大小写的。例如，if是一个关键字，用于条件判断，如果写成IF，编译器会将其视为普通的标识符，而不是条件判断关键字，从而导致语法错误。其他关键字如for、while、class、namespace等都遵循这个规则。

1.3. 字符串内容与字符内容

• 在字符串（string类型）和字符（char类型）内容中，大小写是有意义的。例如，字符串"Hello"和"hello"是不同的内容。在比较字符串是否相等或者进行字符串操作时，大小写会影响结果。可以使用string的方法，如Equals方法（str1.Equals(str2, StringComparison.OrdinalIgnoreCase)可以忽略大小写比较两个字符串是否相等）或者ToUpper（将字符串转换为大写）和ToLower（将字符串转换为小写）方法来处理大小写敏感的问题。对于字符也是一样，字符'A'和'a'是不同的。

1.4 命名

在C#中，变量命名需要遵循一定的规则和约定，以确保代码的可读性、可维护性以及符合编程语言的语法要求。以下是详细的C#变量命名规则：

语法规则

必须以字母、下划线（_）或 @ 符号开头

• 变量名的第一个字符可以是字母（包括英文字母和Unicode字符）、下划线或@符号。例如：

  int _count; // 以下划线开头
  string @name; // 以@符号开头，常用于与关键字冲突的情况
  char letter; // 以字母开头
  

后续字符可以是字母、数字、下划线

• 变量名的第一个字符之后，可以包含字母、数字和下划线。例如：

  int myVariable1;
  string user_name;
  

区分大小写

• C#是区分大小写的语言，因此myVariable和MyVariable是不同的变量名。例如：

  int myVariable = 10;
  int MyVariable = 20; // 这是一个不同的变量
  

不能使用C#关键字作为变量名（除非使用 @ 符号）

• C#有许多保留关键字，如int、string、if、for等，不能直接用作变量名。但如果确实需要使用关键字作为变量名，可以在关键字前加上@符号。例如：

  int @int = 5; // 使用@符号来使用关键字作为变量名
  

不能包含空格或其他特殊字符（除了下划线和 @ 符号）

• 变量名中不能包含空格、标点符号等特殊字符（下划线和@符号除外）。例如，my variable是不合法的变量名，而my_variable是合法的。

命名约定

遵循驼峰命名法

• 小驼峰命名法（camelCase）：对于局部变量、方法参数等，通常使用小驼峰命名法，即第一个单词的首字母小写，后续单词的首字母大写。例如：

  int myVariable;
  void CalculateArea(int baseLength, int height);
  

• 大驼峰命名法（PascalCase）：对于类名、属性名等，通常使用大驼峰命名法，即每个单词的首字母都大写。例如：

  class MyClass
  {
       
      public int MyProperty {
        get; set; }
  }
  

命名要有意义

• 变量名应该能够清晰地表达其用途和含义。避免使用过于简单或无意义的变量名，如a、b、x等，除非在非常简单的示例或临时变量中。例如，使用studentName而不是sn来表示学生的姓名。

避免使用缩写（除非是广泛认可的缩写）

• 尽量使用完整的单词来命名变量，避免使用难以理解的缩写。但对于一些广泛认可的缩写，如id（identifier）、num（number）等，可以使用。例如，使用customerId而不是cid。

常量命名使用全大写，单词间用下划线分隔

• 对于常量（使用const关键字声明的变量），通常使用全大写字母，单词之间用下划线分隔。例如：

  const int MAX_VALUE = 100;
  

遵循这些变量命名规则和约定可以使代码更易于阅读、理解和维护，同时也有助于团队协作和代码的一致性。

1.5 foreach

在C#中，foreach 语句是一种用于遍历集合或数组中每个元素的循环结构，它提供了一种简洁、安全且易于使用的方式来访问集合中的元素。以下是关于 foreach 语句的详细介绍：

基本语法

foreach (var element in collection)
{
   
    // 处理 element 的代码
}

• var：用于声明一个变量，该变量的类型会根据集合中元素的类型自动推断。也可以显式指定变量的类型。
• element：表示集合中的当前元素，在每次循环迭代时，它会依次被赋值为集合中的每个元素。
• collection：表示要遍历的集合或数组，可以是任何实现了 IEnumerable 或 IEnumerable<T> 接口的对象。

使用示例

遍历数组

using System;

class Program
{
   
    static void Main()
    {
   
        int[] numbers = {
    1, 2, 3, 4, 5 };

        foreach (int number in numbers)
        {
   
            Console.WriteLine(number);
        }
    }
}

在这个示例中，foreach 语句遍历了一个整数数组 numbers，并将数组中的每个元素依次赋值给变量 number，然后将其输出到控制台。

遍历列表

using System;
using System.Collections.Generic;

class Program
{
   
    static void Main()
    {
   
        List<string> names = new List<string> {
    "Alice", "Bob", "Charlie" };

        foreach (string name in names)
        {
   
            Console.WriteLine(name);
        }
    }
}

这里，foreach 语句遍历了一个字符串列表 names，并输出列表中的每个元素。

遍历字典

using System;
using System.Collections.Generic;

class Program
{
   
    static void Main()
    {
   
        Dictionary<string, int> scores = new Dictionary<string, int>
        {
   
            {
    "Alice", 85 },
            {
    "Bob", 90 },
            {
    "Charlie", 78 }
        };

        foreach (KeyValuePair<string, int> pair in scores)
        {
   
            Console.WriteLine($"Name: {
     pair.Key}, Score: {
     pair.Value}");
        }
    }
}

对于字典，foreach 语句遍历的是 KeyValuePair<TKey, TValue> 对象，通过 Key 和 Value 属性可以分别访问键和值。

注意事项

• 只读访问：在 foreach 循环中，element 是只读的，不能直接对其进行赋值操作。如果需要修改集合中的元素，通常需要使用 for 循环。

int[] numbers = {
    1, 2, 3 };
foreach (int number in numbers)
{
   
    // 下面这行代码会编译错误，因为 number 是只读的
    // number = number * 2; 
}

• 集合修改：在 foreach 循环遍历集合的过程中，一般不允许修改集合的结构（如添加、删除元素），否则会抛出 InvalidOperationException 异常。

List<int> numbers = new List<int> {
    1, 2, 3 };
foreach (int number in numbers)
{
   
    // 下面这行代码会抛出异常
    // numbers.Add(number * 2); 
}

• 异常处理：如果在 foreach 循环中发生异常，循环会立即终止，并且异常会被抛出。可以使用 try-catch 块来捕获和处理异常。

2 VS2022操作

在C#中建立新的类可以通过以下几种常见的方式，下面会结合示例详细介绍。

1. 在同一项目文件中直接定义新类

• 步骤：
  1. 打开Visual Studio（这里以Visual Studio 2022为例），创建一个新的C#项目（如控制台应用程序）。
  2. 在解决方案资源管理器中，找到要添加类的项目，展开项目节点。
  3. 通常，项目会有一个默认的代码文件（如Program.cs），你可以直接在这个文件中或者新建一个代码文件（如MyClass.cs）来定义新类。
• 示例代码（在MyClass.cs文件中定义一个简单的类）：

// 定义一个新的类，类名为 MyClass
public class MyClass
{
   
    // 类的成员变量
    private string name;

    // 类的构造函数
    public MyClass(string inputName)
    {
   
        name = inputName;
    }

    // 类的方法
    public void PrintName()
    {
   
        Console.WriteLine("Name: " + name);
    }
}

• 使用这个类的示例（在Program.cs中）：

using System;

class Program
{
   
    static void Main()
    {
   
        // 创建 MyClass 类的对象
        MyClass myObject = new MyClass("John");
        // 调用 MyClass 类的方法
        myObject.PrintName();
    }
}

2. 使用Visual Studio的添加新项功能来创建类

• 步骤：
  1. 在解决方案资源管理器中，右键单击项目名称，选择“添加” -> “新建项”。
  2. 在弹出的“添加新项”对话框中，选择“类”模板。
  3. 在“名称”文本框中输入类的名称（如NewClass.cs），然后点击“添加”按钮。
  4. Visual Studio会自动生成一个新的类文件，其中包含一个基本的类定义，你可以在这个文件中编辑类的成员和方法。
• 自动生成的类文件示例（NewClass.cs）：

using System;

namespace YourNamespace // 这里的命名空间会根据项目设置自动生成
{
   
    public class NewClass
    {
   
        // 这里可以添加类的成员变量和方法
    }
}

3. 定义嵌套类（在一个类内部定义另一个类）

• 示例代码：

public class OuterClass
{
   
    // 外部类的成员变量
    private int outerValue;

    // 外部类的构造函数
    public OuterClass(int value)
    {
   
        outerValue = value;
    }

    // 定义一个嵌套类
    public class InnerClass
    {
   
        // 嵌套类的方法
        public void PrintOuterValue(OuterClass outer)
        {
   
            Console.WriteLine("Outer value: " + outer.outerValue);
        }
    }
}

// 使用嵌套类的示例
class Program
{
   
    static void Main()
    {
   
        OuterClass outerObject = new OuterClass(10);
        // 创建嵌套类的对象
        OuterClass.InnerClass innerObject = new OuterClass.InnerClass();
        // 调用嵌套类的方法
        innerObject.PrintOuterValue(outerObject);
    }
}

4. 定义抽象类

• 示例代码：

// 定义一个抽象类
public abstract class Shape
{
   
    // 抽象方法，没有具体实现，需要在派生类中实现
    public abstract double CalculateArea();
}

// 派生类继承自抽象类
public class Circle : Shape
{
   
    private double radius;

    public Circle(double r)
    {
   
        radius = r;
    }

    // 实现抽象方法
    public override double CalculateArea()
    {
   
        return Math.PI * radius * radius;
    }
}

// 使用抽象类和派生类的示例
class Program
{
   
    static void Main()
    {
   
        Circle circle = new Circle(5);
        double area = circle.CalculateArea();
        Console.WriteLine("Circle area: " + area);
    }
}

以上就是在C#中建立新类的几种常见方式和相关示例，你可以根据具体的需求选择合适的方式来定义类。

在WinForm中改变窗体的字体，可通过设计器和代码两种方式实现，以下是具体的操作方法：

Winform改变字体

1. 使用设计器改变窗体字体

步骤：

• 打开Visual Studio并加载你的WinForm项目。
• 在解决方案资源管理器中，双击要更改字体的窗体文件（通常是 Form1.cs），打开窗体设计器。
• 在窗体设计器中，右键单击窗体空白处，选择“属性”，或者直接按 F4 键打开属性窗口。
• 在属性窗口中，找到 Font 属性，点击其右侧的省略号（...）按钮，打开“字体”对话框。
• 在“字体”对话框中，选择你想要的字体、字号和样式（如加粗、倾斜等），然后点击“确定”按钮。

2. 使用代码改变窗体字体

步骤：

• 打开窗体的代码文件（如 Form1.cs）。
• 在窗体的构造函数或其他合适的方法中，使用以下代码来更改窗体的字体：

using System;
using System.Drawing;
using System.Windows.Forms;

namespace WinFormFontChangeExample
{
   
    public partial class Form1 : Form
    {
   
        public Form1()
        {
   
            InitializeComponent();

            // 创建一个新的字体对象
            Font newFont = new Font("微软雅黑", 12, FontStyle.Regular);

            // 将新字体应用到窗体
            this.Font = newFont;
        }
    }
}

代码解释：

• Font 类用于表示字体，通过 new Font("微软雅黑", 12, FontStyle.Regular) 创建了一个新的字体对象，其中 "微软雅黑" 是字体名称，12 是字号，FontStyle.Regular 表示常规样式（不加粗、不倾斜）。
• this.Font = newFont; 将新创建的字体对象应用到当前窗体。

3. 批量改变窗体上所有控件的字体

如果需要同时改变窗体上所有控件的字体，可以使用递归方法遍历窗体上的所有控件，并设置它们的字体：

using System;
using System.Drawing;
using System.Windows.Forms;

namespace WinFormFontChangeExample
{
   
    public partial class Form1 : Form
    {
   
        public Form1()
        {
   
            InitializeComponent();

            // 创建一个新的字体对象
            Font newFont = new Font("微软雅黑", 12, FontStyle.Regular);

            // 调用方法改变窗体及所有控件的字体
            ChangeFont(this, newFont);
        }

        private void ChangeFont(Control control, Font newFont)
        {
   
            // 设置当前控件的字体
            control.Font = newFont;

            // 遍历当前控件的所有子控件
            foreach (Control childControl in control.Controls)
            {
   
                // 递归调用ChangeFont方法，改变子控件的字体
                ChangeFont(childControl, newFont);
            }
        }
    }
}

代码解释：

• ChangeFont 方法接受一个 Control 类型的参数和一个 Font 类型的参数，用于递归地改变控件及其子控件的字体。
• 在 Form1 的构造函数中，调用 ChangeFont 方法并传入当前窗体和新字体对象，从而实现批量改变字体的效果。

通过以上方法，你可以在WinForm中方便地改变窗体及其控件的字体。

Label添加

在Visual Studio 2022中，“标签（Label）”通常是指WinForm设计器中的Label控件，如果你想问的是在WinForm设计器中如何添加Label控件，或者是如何调出显示属性等相关窗口，以下是具体介绍：

调出Label控件进行添加

1. 打开WinForm设计器

   • 首先确保你已经创建了一个Windows Forms应用程序项目。在解决方案资源管理器中，双击.cs窗体文件（例如Form1.cs），打开WinForm设计器界面。

2. 找到工具箱

   • 通常，工具箱会默认停靠在Visual Studio界面的左侧。如果没有显示，可以通过“视图”菜单，选择“工具箱”来将其显示出来。

3. 添加Label控件

   • 在工具箱中，展开“所有Windows窗体”或“公共控件”分组（具体名称可能因版本和设置略有不同），找到Label控件。
   • 点击并按住Label控件，然后将其拖动到WinForm设计器的窗体上你想要放置的位置，松开鼠标即可添加一个Label控件到窗体上。

调出Label控件的属性窗口

1. 选中Label控件

   • 在WinForm设计器中，点击你之前添加的Label控件，使其处于选中状态（控件周围会出现蓝色的边框）。

2. 打开属性窗口

   • 一般情况下，属性窗口会默认停靠在Visual Studio界面的右侧。如果没有显示，可以通过以下两种方式调出：
     • 使用快捷键F4，可以快速打开或切换到属性窗口。
     • 通过“视图”菜单，选择“属性窗口”来显示属性窗口。

3. 查看和修改Label控件的属性

   • 在属性窗口中，可以看到Label控件的各种属性，如Text（用于设置显示的文本内容）、Font（用于设置字体）、ForeColor（用于设置文本颜色）等。你可以根据需要修改这些属性的值。

调出Label控件的事件窗口（如果需要处理事件）

1. 选中Label控件

   • 同样在WinForm设计器中，点击选中Label控件。

2. 打开事件窗口

   • 可以通过以下两种方式打开事件窗口：
     • 使用快捷键Shift + F4。
     • 通过“视图”菜单，选择“事件窗口”。

3. 处理Label控件的事件

   • 在事件窗口中，可以看到Label控件支持的各种事件，如Click（点击事件）、MouseEnter（鼠标进入事件）等。双击你想要处理的事件名称，Visual Studio会自动在代码文件中生成相应的事件处理方法的框架，你可以在其中编写具体的代码逻辑。

3 函数

3.1 输出Console.Write

在C#中，Console.WriteLine和Console.Write都是用于向控制台输出信息的方法，但它们之间有一些重要的区别。

1. 输出后是否换行

• Console.WriteLine：
  • Console.WriteLine方法在输出完指定的信息后，会自动在输出的末尾添加一个换行符，将光标移动到下一行的开头。
  • 示例代码：

Console.WriteLine("第一行");
Console.WriteLine("第二行");

• 输出结果：

第一行
第二行

• Console.Write：
  • Console.Write方法仅输出指定的信息，不会在输出的末尾添加换行符，光标会停留在输出内容的末尾。
  • 示例代码：

Console.Write("第一行");
Console.Write("第二行");

• 输出结果：

第一行第二行

2. 重载方法的功能

• Console.WriteLine：
  • Console.WriteLine有多个重载方法，除了可以输出字符串，还可以直接输出各种基本数据类型（如整数、浮点数等），并且会自动调用这些数据类型的ToString方法将其转换为字符串输出，同时在末尾添加换行符。
  • 示例代码：

int number = 123;
Console.WriteLine(number);

• 输出结果：

123

• Console.Write：
  • Console.Write同样有多个重载方法，可以输出各种基本数据类型，它会将这些数据类型转换为字符串输出，但不会添加换行符。
  • 示例代码：

int number1 = 123;
int number2 = 456;
Console.Write(number1);
Console.Write(number2);

• 输出结果：

123456

3.2 Console.ReadKey

在C#中，Console.ReadKey 是一个用于从控制台读取用户按下的下一个字符或功能键的方法，它属于 System.Console 类。如果后面没有代码，则自动退出调试。

以下是关于 Console.ReadKey 的详细介绍：

方法重载

Console.ReadKey 有两个重载形式：

1. public static ConsoleKeyInfo ReadKey ();

   • 这个重载会读取用户按下的下一个字符或功能键，并将其作为 ConsoleKeyInfo 对象返回，同时显示按下的字符（如果是可显示字符）。

2. public static ConsoleKeyInfo ReadKey (bool intercept);

   • 此重载方法接受一个布尔类型的参数 intercept。当 intercept 为 true 时，用户按下的键不会显示在控制台中；当 intercept 为 false 时，用户按下的键会显示在控制台中。

返回值

Console.ReadKey 方法返回一个 ConsoleKeyInfo 类型的对象，该对象包含以下重要属性：

• Key：一个 ConsoleKey 枚举值，表示用户按下的键，如 ConsoleKey.Enter、ConsoleKey.Escape 等。
• KeyChar：一个 char 类型的值，表示用户按下的键对应的字符（如果该键有对应的字符）。对于功能键（如 F1、F2 等），KeyChar 可能是 \u0000。
• Modifiers：一个 ConsoleModifiers 枚举值，表示用户按下的修饰键（如 Shift、Ctrl、Alt 等）的组合。

示例代码

以下是几个使用 Console.ReadKey 的示例：

基本用法

using System;

class Program
{
   
    static void Main()
    {
   
        Console.WriteLine("请按任意键继续...");
        ConsoleKeyInfo keyInfo = Console.ReadKey();
        Console.WriteLine(); // 换行
        Console.WriteLine($"你按下的键是：{
     keyInfo.Key}");
        Console.WriteLine($"对应的字符是：{
     keyInfo.KeyChar}");
    }
}

在这个示例中，程序会等待用户按下一个键，然后输出用户按下的键的信息。

使用 intercept 参数

using System;

class Program
{
   
    static void Main()
    {
   
        Console.WriteLine("请输入密码（输入时不显示字符）：");
        string password = "";
        ConsoleKeyInfo keyInfo;

        do
        {
   
            keyInfo = Console.ReadKey(true); // 不显示输入的字符
            if (keyInfo.Key != ConsoleKey.Enter)
            {
   
                password += keyInfo.KeyChar;
            }
        } while (keyInfo.Key != ConsoleKey.Enter);

        Console.WriteLine(); // 换行
        Console.WriteLine($"你输入的密码是：{
     password}");
    }
}

在这个示例中，通过将 intercept 参数设置为 true，实现了在用户输入密码时不显示字符的效果。

根据用户输入的键执行不同操作

using System;

class Program
{
   
    static void Main()
    {
   
        Console.WriteLine("请选择操作：");
        Console.WriteLine("1. 显示信息");
        Console.WriteLine("2. 退出");

        ConsoleKeyInfo keyInfo = Console.ReadKey();

        switch (keyInfo.KeyChar)
        {
   
            case '1':
                Console.WriteLine(); // 换行
                Console.WriteLine("你选择了显示信息。");
                break;
            case '2':
                Console.WriteLine(); // 换行
                Console.WriteLine("程序退出。");
                return;
            default:
                Console.WriteLine(); // 换行
                Console.WriteLine("无效的选择。");
                break;
        }
    }
}

在这个示例中，根据用户按下的键执行不同的操作。

注意事项

• Console.ReadKey 方法会阻塞当前线程，直到用户按下一个键。
• 在某些情况下，Console.ReadKey 可能会受到控制台的输入模式、缓冲区设置等因素的影响。
• 在使用 Console.ReadKey 时，要注意处理不同的键和修饰键组合，以确保程序的健壮性。

3.3 ///

在C#中，/// 是一种特殊的注释语法，用于生成XML文档注释。这些注释可以被Visual Studio等开发工具解析，用于生成代码的文档信息，帮助开发者更好地理解代码的功能和使用方法。以下是关于 /// 注释的详细介绍：

基本功能

当在代码中使用 /// 开始一行注释时，编译器会将这些注释作为XML格式的文档信息进行处理。这些注释通常用于描述类、方法、属性、字段等代码元素的用途、参数、返回值等信息。

使用场景和示例

类的文档注释

/// <summary>
/// 表示一个人的基本信息类。
/// 该类包含人的姓名和年龄信息，并提供了相应的属性进行访问。
/// </summary>
public class Person
{
   
    /// <summary>
    /// 获取或设置人的姓名。
    /// </summary>
    public string Name {
    get; set; }

    /// <summary>
    /// 获取或设置人的年龄。
    /// </summary>
    public int Age {
    get; set; }

    /// <summary>
    /// 构造函数，用于初始化人的姓名和年龄。
    /// </summary>
    /// <param name="name">人的姓名。</param>
    /// <param name="age">人的年龄。</param>
    public Person(string name, int age)
    {
   
        Name = name;
        Age = age;
    }

    /// <summary>
    /// 打印人的基本信息。
    /// </summary>
    public void PrintInfo()
    {
   
        Console.WriteLine($"姓名：{
     Name}，年龄：{
     Age}");
    }
}

方法的文档注释

在上述示例中，Person 类的构造函数和 PrintInfo 方法都使用了 /// 注释。对于方法，通常会使用 <summary> 标签来描述方法的功能，使用 <param> 标签来描述方法的参数，使用 <returns> 标签（如果方法有返回值）来描述方法的返回值。

XML文档注释标签

以下是一些常用的XML文档注释标签：

• <summary>：用于提供对代码元素（如类、方法、属性等）的简要描述。
• <param>：用于描述方法的参数，需要指定参数的名称。
• <returns>：用于描述方法的返回值。
• <remarks>：用于提供额外的详细说明。
• <example>：用于提供代码示例，展示如何使用该代码元素。
• <exception>：用于描述方法可能抛出的异常。

生成文档

在Visual Studio中，可以通过以下步骤生成XML文档：

1. 右键单击项目，选择“属性”。
2. 在“生成”选项卡中，勾选“XML文档文件”，并指定文档文件的输出路径和名称。
3. 编译项目后，会在指定的路径生成一个XML文档文件，其中包含了代码中的文档注释信息。

查看文档

生成的XML文档可以通过Visual Studio的智能感知功能查看。当你在代码中使用某个类或方法时，鼠标悬停在上面，就可以看到相应的文档注释信息。

综上所述，/// 注释在C#中用于生成XML文档注释，帮助开发者编写更易于理解和维护的代码。

3.3 region

在C#中，#region 和 #endregion 是预处理器指令，用于在代码中创建可折叠的代码区域。这两个指令主要用于组织和管理代码，提高代码的可读性和可维护性，特别是在处理大型代码文件时非常有用。

基本语法

#region 区域名称
// 这里是代码区域的内容
#endregion

功能和用途

代码组织和折叠

• 使用 #region 和 #endregion 可以将一段相关的代码块分组，并为这个代码块指定一个名称（区域名称）。在Visual Studio等集成开发环境（IDE）中，这些代码区域可以被折叠起来，只显示区域的名称，从而减少代码的视觉复杂度，让开发者能够更方便地浏览和管理代码。

示例

using System;

namespace RegionExample
{
   
    class Program
    {
   
        static void Main()