02C#基本结构篇（D4_注释-访问修饰符-标识符-关键字-运算符-流程控制语句）

一、注释

1. 单行注释

2. 多行注释

3. XML文档注释

4. 使用建议和最佳实践：

二、访问修饰符

1. public

2. private

3. protected

4. internal

5. protected internal 或 protected and internal

6. private protected 或 private and protected

7. 使用场景

三、标识符

1. 命名规则

2. 命名约定

3. 关键字和保留字

4. 使用@符号

5. 最佳实践

四、关键字

1. 访问修饰符

2. 类型关键字

3. 方法修饰符

4. 属性修饰符

5. 字段修饰符

6. 声明变量和类型

7. 控制流关键字

8. 其他关键字

9. 上下文关键字（Contextual Keywords）

---------------

七、方法

1. 方法的定义

2. 示例

3. 方法的调用

4. 参数传递方式

5. 方法重载（Overloading）

6. 可选参数和命名参数（C# 4.0及以后）

7. 表达式体定义方法（C# 6.0及以后）

8. 异步方法（Async/Await）

-------------------------------------------

八、构造器

1. 实例构造器

1.1. 2. 静态构造器

2. 构造器的特性与使用场景

3. 构造器的调用顺序

4. 构造函数链（Chaining）

一、注释

在C#中，注释是用来在代码中添加说明性文字的，它们不会被编译器执行，但有助于提高代码的可读性和维护

性。C#支持三种类型的注释：

单行注释
多行注释
XML文档注释

1. 单行注释

单行注释使用//开头，从//开始到该行结束的所有内容都会被视为注释。

示例：

// 这是一个单行注释
int number = 5; // 这也是单行注释

2. 多行注释

多行注释使用/*开头，以*/结尾。它们可以跨越多行。

示例：

/* 这是一个多行注释的开始这是多行注释的中间部分这是多行注释的结束 */
int number = 10; // 这行代码不会被视为多行注释的一部分

3. XML文档注释

XML文档注释以///开头，这种注释通常用于生成文档（例如，使用Visual Studio的XML文档注释工具）。它

们遵循XML的格式，可以包含标签和属性，用于提供更丰富的代码描述信息。

示例：

/// <summary>
/// 这是一个计算两个数字之和的方法。
/// </summary>
/// <param name="a">第一个数字</param>
/// <param name="b">第二个数字</param>
/// <returns>返回两个数字的和</returns>
public int Add(int a, int b)
{return a + b;
}

4. 使用建议和最佳实践：

保持代码清晰：使用注释来解释复杂的逻辑、算法或者为什么这样实现。
避免过度注释：好的代码应该尽可能自解释，过多的注释可能会让代码显得杂乱无章。
更新和维护：当代码发生变化时，确保相关的注释也随之更新，避免误导。
使用XML文档注释生成文档：对于公开的API或库，使用XML文档注释可以帮助自动生成文档，这对于维护和团队协作非常有帮助。
遵循团队的编码规范：如果在一个团队中工作，确保所有成员遵循相同的注释规范和风格。

通过合理使用这些注释技巧，你可以显著提高代码的可读性和维护性。

二、访问修饰符

在C#中，访问修饰符是用来控制类、方法、属性、事件和索引器等成员的访问权限的。它们决定了这些成员可以

被哪些代码访问。C#中共有五种访问修饰符，每种都有其特定的用途和范围。以下是这五种访问修饰符的详细解

释：

1. public

public 修饰符表示成员可以被任何其他代码访问，无论是同一个程序集内的代码还是其他程序集的代码。

示例：public class MyClass { } 表示这个类可以在任何地方被访问。

2. private

private 修饰符表示成员只能被定义它的类内部访问。

这意味着，即使是在同一个程序集内，其他类也无法访问该成员。

示例：private int myVariable; 表示这个变量只能在定义它的类内部被访问。

3. protected

protected 修饰符表示成员可以被定义它的类以及所有派生类（子类）访问。

但是，如果这个成员位于不同的程序集，那么只有在派生类位于同一个程序集内时才能访问。

示例：protected virtual void MyMethod() { } 表示这个方法可以在派生类中被重写和调用。

4. internal

internal 或称为 assembly 修饰符表示成员可以被同一个程序集内的任何代码访问，但不能被其他程序集的代码

访问。

示例：internal class MyInternalClass { } 表示这个类只能在定义它的程序集内被访问。

5. protected internal 或 protected and internal

protected internal 修饰符是 protected 和 internal 的组合，表示成员可以被定义它的类、所有派生类以及同

一个程序集内的任何代码访问，但不能被其他程序集的代码访问。

示例：protected internal string MyProperty { get; set; }

表示这个属性可以在派生类和同一个程序集内被访问，但不能被其他程序集访问。

6. private protected 或 private and protected

private protected 是C# 7.2引入的，它结合了 private 和 protected 的特性，使得成员只能被定义它的类和所

有派生类（无论是否在同一程序集内）访问。

示例：private protected void MyMethod() { } 表示这个方法只能在定义它的类和所有派生类中被访问。

7. 使用场景

public：当你希望类的成员对所有外部代码都可见时使用。
private：当你希望类的成员仅在其定义的类内部可用时使用。
protected：当你希望类的成员在其自身和派生类中可用时使用。
internal：当你希望类的成员在同一个程序集内可用时使用。
protected internal：当你希望类的成员在同一个程序集内或在派生类中可用时使用。
private protected：当你希望类的成员在定义它的类和所有派生类中可用时使用，无论它们是否在同一程序集内。

正确选择和使用这些访问修饰符对于设计良好的、可维护的C#代码非常重要。

三、标识符

在C#中，标识符是用来命名变量、方法、类、接口、事件、属性等元素的名称。

它们遵循一系列规则和约定，以确保代码的可读性和一致性。

下面是一些关于C#中标识符的重要规则和细节：

1. 命名规则

首字母规则：标识符可以以字母或下划线（_）开头。在C#中，标识符不能以下划线开头。
后续字符规则：标识符可以包含字母、数字、下划线（_）和@符号。但是，不能包含空格或其他特殊字符。
大小写敏感：C#是大小写敏感的，这意味着variable和Variable被视为两个不同的标识符。

2. 命名约定

C#社区遵循一些命名约定，以提高代码的可读性和维护性：

驼峰命名法（Camel Case）：

- 小驼峰命名法（lowerCamelCase）：第一个单词的首字母小写，后续单词的首字母大写。例如：myVariable。
- 大驼峰命名法（UpperCamelCase或PascalCase）：每个单词的首字母都大写。例如：MyClass。

匈牙利命名法（Hungarian Notation）：尽管不常用，但某些旧代码中仍可见。匈牙利命名法通过在变量名前加上一个或多个字母来表示变量的类型或作用。例如：iCount表示一个整型计数器。

3. 关键字和保留字

C#有一些关键字和保留字不能用作标识符，因为它们已经被赋予了特定的意义。例如：

int class = 5; // 错误，因为'class'是C#的关键字

完整的C#关键字列表可以在官方文档中找到，例如：C# Keywords。

4. 使用@符号

如果你需要使用一个以关键字命名的变量名，或者变量名与C#的保留字冲突，你可以在变量名前加上@符号

来“转义”关键字或保留字。例如：

int @class = 5; // 正确，使用@来避免关键字冲突

5. 最佳实践

清晰和描述性：选择能够清晰描述变量或对象用途的名称。
一致性：在项目中保持一致的命名约定。
避免混淆：避免使用可能引起混淆的缩写或过于简短的名称。

示例

public class MyClass {private int myVariable; // 小驼峰命名法private int MyProperty { get; set; } // 大驼峰命名法，用于属性public static void Main() {int iCount = 10; // 小驼峰命名法，表示一个计数器Console.WriteLine(iCount);}
}

遵循这些规则和最佳实践将有助于编写更清晰、更易于维护的C#代码。

四、关键字

在C#中，关键字是用来表示程序中特定功能的词汇，它们在编程时具有特殊的含义和用途。了解这些关键字对于

编写有效的C#代码至关重要。C#的关键字可以分为以下几类：

1. 访问修饰符

public：允许访问的类型或成员可以被任何其他代码访问。
private：限制访问的类型或成员只能被其所属的类访问。
protected：允许访问的类型或成员只能被其所属的类或派生类访问。
internal：允许访问的类型或成员只能在同一个程序集内被访问。
protected internal：允许访问的类型或成员只能在同一个程序集内或派生类中被访问。
private protected：允许访问的类型或成员只能在同一个程序集内的派生类中被访问。

2. 类型关键字

class：定义一个类。
struct：定义一个值类型结构体。
interface：定义一个接口。
enum：定义一个枚举类型。
delegate：定义一个委托。

3. 方法修饰符

static：表示方法属于类而不是类的实例。
virtual：表示方法可以在派生类中被重写。
override：表示方法重写基类中的虚方法。
abstract：表示方法在派生类中必须被重写。
sealed：阻止方法被重写。

4. 属性修饰符

get：用于获取属性值的方法。
set：用于设置属性值的方法。
readonly：指示属性只可读，不可写。

5. 字段修饰符

const：定义一个常量字段。
readonly：定义一个只读字段，其值必须在声明时或在构造函数中初始化。
volatile：指示字段可能由多个线程同时修改，编译器应避免优化该字段的访问。

6. 声明变量和类型

var：自动推断变量的类型（C# 3.0引入）。
dynamic：在运行时解析类型（C# 4.0引入）。
ref：引用传递参数（传递变量的引用而不是值）。
out：用于方法参数，表示该参数用于从方法返回一个值（通常用在返回多个值时）。
params：用于方法的参数，允许传递零个或多个参数。

7. 控制流关键字

if、else、switch、case、default、while、do、for、foreach、break、continue、goto、return、try、catch、finally、throw、checked、unchecked。

8. 其他关键字

using：用于声明命名空间或使用资源（如文件、数据库连接等）。
namespace：定义命名空间。
class、struct、interface、enum、delegate 等用于定义类型的关键字也在此分类下，但它们属于类型关键字类别。
null：表示空引用或空指针。
true 和 false：布尔值的字面量。
sizeof: 在不安全代码中，用于获取类型的字节大小。
lock: 用于锁定对象，确保线程安全地访问共享资源。
yield: 在迭代器块中使用，用于返回序列中的元素。
async 和 await: 用于异步编程模型中，使异步方法更易于编写和使用。

9. 上下文关键字（Contextual Keywords）

这些关键字在不同的上下文中可能有不同的含义，例如在泛型编程中：

where: 在泛型约束中使用，例如指定类型参数必须继承自某个类或实现某个接口。
in: 在泛型编程中指定协变（C# 7.3及以后版本）。
out: 在泛型编程中指定逆变（C# 7.3及以后版本）。

了解这些关键字及其用途对于编写高效和正确的C#代码至关重要。在实际开发中，合理地使用这些关键字可以提

高代码的可读性和维护性。

---------------

七、方法

在C#中，方法（也称为函数）是执行特定任务的代码块。它们可以被定义在一个类中，并被其他类或方法调用。

C#中的方法可以是静态的（属于类本身）或实例的（属于类的实例）。下面将详细解释C#中方法的各个方面。

1. 方法的定义

一个C#方法的基本定义格式如下：

[访问修饰符] [返回类型] 方法名([参数列表])
{// 方法体
}

访问修饰符：如 public, private, protected, internal 等，控制方法的访问权限。
返回类型：方法返回的数据类型，如果是void则表示不返回任何值。
方法名：标识符，遵循C#的命名规则。
参数列表：括号内包含一个或多个参数，每个参数由类型和名称组成，参数间用逗号分隔。
方法体：包含执行任务的代码块。

2. 示例

public class ExampleClass
{// 无参数无返回值的方法public void SayHello(){Console.WriteLine("Hello, World!");}// 有参数有返回值的方法public int Add(int a, int b){return a + b;}
}

3. 方法的调用

静态方法：使用类名直接调用。

ExampleClass.SayHello(); // 需要是静态方法或静态属性访问方式

实例方法：首先创建类的实例，然后通过该实例调用。

ExampleClass example = new ExampleClass();
example.SayHello(); // 调用非静态方法
int result = example.Add(5, 3); // 调用非静态方法并获取返回值

4. 参数传递方式

C#支持按值传递（默认）和按引用传递（使用ref或out关键字）。

按值传递：传递参数的副本，对副本的修改不会影响原始参数。
按引用传递：直接传递参数的内存地址，对参数的修改会影响原始参数。ref用于修改传入的参数值，out用于在方法内部给参数赋值。

5. 方法重载（Overloading）

同一个类中可以有多个同名方法，只要它们的参数列表不同（参数数量或类型不同）。这称为方法重载。

public void Show(int a) { }
public void Show(string text) { }

6. 可选参数和命名参数（C# 4.0及以后）

从C# 4.0开始，可以在方法定义时为参数提供默认值，使其成为可选参数。还可以在调用时使用命名参数。

public void Print(string message = "Default Message") { }
Print("Hello"); // 使用默认值和命名参数调用Print方法。

7. 表达式体定义方法（C# 6.0及以后）

从C# 6.0开始，可以使用表达式体来定义简单的只返回一个表达式结果的方法。

public int Multiply(int a, int b) => a * b; // 相当于 { return a * b; } 的简写形式。

8. 异步方法（Async/Await）

C#支持异步编程模式，允许方法在等待操作完成时释放线程，使用async和await关键字。

public async Task<int> GetDataAsync() 
{ // 使用await调用异步方法并获取结果 return await SomeAsyncMethod(); 
}

通过以上介绍，你应该对C#中的方法有了一个全面的理解。

每种方法和概念都可以帮助你更有效地编写和组织代码。

-------------------------------------------

八、构造器

在C#中，构造器（Constructor）是一种特殊的方法，用于在创建对象时初始化对象。构造器与类同名，没有返回

类型，主要用于分配内存并初始化对象。C#中有两种类型的构造器：实例构造器（用于创建对象实例）和静态构

造器（用于初始化静态成员）。

1. 实例构造器

实例构造器用于创建类的实例，并初始化对象的状态。每个类可以有多个构造器，只要它们的参数列表不同。

示例

public class Person
{public string Name { get; set; }public int Age { get; set; }// 无参数构造器public Person(){Name = "Unknown";Age = 0;}// 带参数的构造器public Person(string name, int age){Name = name;Age = age;}
}

1.1. 2. 静态构造器

静态构造器用于初始化类的静态成员。静态构造器是类的一部分，而不是实例的一部分。静态构造器在类第一次

被引用时自动调用，仅执行一次。

示例

public class DatabaseConnection
{private static string connectionString;// 静态构造器static DatabaseConnection(){connectionString = "Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;";}
}

2. 构造器的特性与使用场景

无参数构造器：通常用于提供一个默认的初始化状态。如果类中没有定义任何构造器，编译器会自动提供一个无参数的默认构造器。一旦你定义了任何构造器（无论是带参数的还是无参数的），编译器就不会自动提供默认的无参数构造器。
带参数的构造器：允许在创建对象时传递不同的初始值。这增加了对象的灵活性，使得可以根据需要创建具有不同初始状态的多个对象实例。
构造函数重载：通过定义多个具有不同参数列表的构造器，可以实现构造函数重载。这允许根据提供的参数创建不同类型的对象实例。

3. 构造器的调用顺序

父类构造器的调用：在派生类的构造器中，必须首先调用基类的构造器（除非基类是无参数的默认构造器）。这通常通过使用 :base() 语法完成。例如：public ChildClass(string name) : base(name)。
静态构造器的调用：静态构造器在类第一次被引用时自动调用，用于初始化静态成员。它不能被直接调用，也不能带有访问修饰符或参数。

4. 构造函数链（Chaining）

在派生类的构造函数中，可以使用 this() 来调用基类的另一个构造函数。例如：

public class ChildClass : BaseClass
{public ChildClass(string name) : base(name) // 调用基类的带参数的构造器{// 子类的初始化代码}
}

通过以上介绍，你可以更好地理解C#中构造器的使用和它们的重要性。