09. C#入门系列【深入理解类】：探索类的神秘腹地

C#入门系列【深入理解类】：探索类的神秘腹地

各位编程探险家们，欢迎回来！上次我们在C#的奇幻大陆上初识了类这个重要“建筑”，今天我们要深入类的神秘腹地，探索那些更高级、更强大的类成员和特性。准备好了吗？让我们再次开启这场充满惊喜的编程冒险之旅！

一、类成员

1. 常量：类的“永恒不变法则”

在类的世界里，有些东西就像宇宙中的物理定律一样，一旦确定就永远不会改变，这就是常量。常量是在编译时就确定值，并且在整个程序运行过程中都不会发生变化的量。在C#中，使用const关键字来声明常量。

比如，我们在设计一个数学工具类时，圆周率π就是一个常量：

class MathUtils
{public const double PI = 3.14159265358979323846;public static double CalculateCircleArea(double radius){return PI * radius * radius;}
}

常量的特点是：

必须在声明时就赋值，之后不能再修改。
隐式静态，但不能使用static关键字修饰。
只能是内置值类型或字符串。

使用常量可以提高代码的可读性和可维护性，避免在代码中重复使用硬编码的值。

2. 析构函数：对象的“临终遗言”

我们之前学过构造函数，它是对象诞生时的“接生婆”，而析构函数则是对象“临终前”的“告别演说家”。当对象不再被使用，垃圾回收器准备回收它的内存时，析构函数会被自动调用。

析构函数的语法很有特点，是在类名前加一个波浪线~：

class DatabaseConnection
{private IntPtr dbHandle;// 构造函数：初始化资源public DatabaseConnection(){dbHandle = OpenDatabase(); // 假设这是一个打开数据库的方法}// 析构函数：释放资源~DatabaseConnection(){CloseDatabase(dbHandle); // 关闭数据库连接Console.WriteLine("数据库连接已关闭");}// 省略其他方法...
}

析构函数的特点：

不能有参数和访问修饰符。
不能手动调用，由垃圾回收器自动调用。
主要用于释放非托管资源（如文件句柄、数据库连接等）。

不过要注意，析构函数的执行时间是不确定的，所以在实际开发中，对于需要及时释放的资源，我们通常会实现IDisposable接口，使用using语句或手动调用Dispose方法来释放资源。

3. 运算符：让类“玩转数学魔法”

在C#中，我们可以通过运算符重载让类的对象像基本数据类型一样参与运算，这就像是给类赋予了“数学魔法”的能力。比如，我们可以定义两个“向量”对象相加的运算规则。

要重载运算符，需要使用operator关键字，并且声明为public static：

class Vector
{public double X { get; set; }public double Y { get; set; }public Vector(double x, double y){X = x;Y = y;}// 重载加法运算符public static Vector operator +(Vector v1, Vector v2){return new Vector(v1.X + v2.X, v1.Y + v2.Y);}// 重载减法运算符public static Vector operator -(Vector v1, Vector v2){return new Vector(v1.X - v2.X, v1.Y - v2.Y);}// 重载乘法运算符（向量与标量相乘）public static Vector operator *(Vector v, double scalar){return new Vector(v.X * scalar, v.Y * scalar);}
}

使用重载的运算符就像使用基本数据类型一样自然：

Vector v1 = new Vector(1, 2);
Vector v2 = new Vector(3, 4);
Vector sum = v1 + v2; // 调用重载的+运算符
Vector product = v1 * 2; // 调用重载的*运算符

需要注意的是，并不是所有运算符都可以重载，而且重载运算符时要遵循合理的语义，不能滥用。

4. 索引器：让对象像数组一样灵活

索引器允许类的对象像数组一样通过索引来访问其元素，这为类提供了一种直观且方便的数据访问方式。比如，我们可以设计一个“字符串集合”类，通过索引来访问其中的字符串。

索引器的语法是使用this关键字加上方括号：

class StringCollection
{private string[] items = new string[100];// 索引器定义public string this[int index]{get{if (index >= 0 && index < items.Length)return items[index];throw new IndexOutOfRangeException();}set{if (index >= 0 && index < items.Length)items[index] = value;elsethrow new IndexOutOfRangeException();}}
}

使用索引器就像使用数组一样简单：

StringCollection collection = new StringCollection();
collection[0] = "Hello";
collection[1] = "World";
Console.WriteLine(collection[0]); // 输出 "Hello"

索引器可以有多个参数，也可以是只读或只写的，甚至可以重载，以支持不同类型的索引。

5. 事件：类的“广播电台”

事件是类与外部世界通信的一种机制，就像一个“广播电台”，当特定的事情发生时，它会发出通知。其他对象可以“收听”这个广播，并做出相应的反应。

在C#中，事件基于委托实现。下面是一个简单的事件示例：

// 定义事件委托
public delegate void CarStartedEventHandler(object sender, EventArgs e);class Car
{// 定义事件public event CarStartedEventHandler CarStarted;public void Start(){Console.WriteLine("汽车启动了");// 触发事件CarStarted?.Invoke(this, EventArgs.Empty);}
}// 使用事件
class Program
{static void Main(){Car car = new Car();// 订阅事件car.CarStarted += Car_CarStarted;car.Start(); // 启动汽车，触发事件}static void Car_CarStarted(object sender, EventArgs e){Console.WriteLine("收到通知：汽车已启动");}
}

事件的使用分三个步骤：定义委托、声明事件、订阅和触发事件。事件是实现观察者模式的一种重要方式，在GUI编程、多线程编程等场景中经常会用到。

二、静态成员

静态成员属于类本身，而不是类的某个实例。它们就像是类的“公共财产”，所有实例都可以共享访问。静态成员可以提高代码的效率和可维护性，特别是在需要共享数据或方法的情况下。

1. 静态字段：类的“共享存钱罐”

静态字段是类级别的变量，所有类的实例都共享同一个静态字段的值。就像一个“共享存钱罐”，大家都可以往里面存钱或取钱。

class Counter
{public static int Count = 0; // 静态字段public Counter(){Count++; // 每次创建实例时，计数器加1}
}// 使用静态字段
class Program
{static void Main(){Console.WriteLine(Counter.Count); // 输出 0Counter c1 = new Counter();Console.WriteLine(Counter.Count); // 输出 1Counter c2 = new Counter();Console.WriteLine(Counter.Count); // 输出 2}
}

静态字段通常用于存储类级别的数据，如计数器、配置信息等。

2. 静态方法：类的“公共工具”

静态方法是属于类而不是实例的方法，它们就像是类提供的“公共工具”，不需要创建实例就可以使用。静态方法只能访问静态成员，不能访问实例成员。

class MathHelper
{// 静态方法：计算两个数的和public static double Add(double a, double b){return a + b;}// 静态方法：计算两个数的积public static double Multiply(double a, double b){return a * b;}
}// 使用静态方法
class Program
{static void Main(){double result = MathHelper.Add(3, 4); // 直接通过类名调用Console.WriteLine(result); // 输出 7}
}

静态方法常用于实现通用的功能，如数学计算、数据转换等。

3. 静态属性：类的“智能共享数据”

静态属性就像是类的“智能共享数据”，它结合了静态字段和属性的优点，既可以像静态字段一样被所有实例共享，又可以像属性一样进行数据验证和逻辑处理。

class Configuration
{private static string _appName;public static string AppName{get { return _appName; }set{if (string.IsNullOrEmpty(value))throw new ArgumentException("应用名称不能为空");_appName = value;}}
}// 使用静态属性
class Program
{static void Main(){Configuration.AppName = "My Application"; // 设置静态属性Console.WriteLine(Configuration.AppName); // 获取静态属性}
}

静态属性通常用于存储和管理类级别的配置信息或状态。

4. 静态构造函数：类的“初始化仪式”

静态构造函数用于初始化类的静态成员，它在类被加载时自动执行，而且只执行一次。就像是类的“初始化仪式”，在类正式“登场”之前，做好一切准备工作。

class Database
{public static string ConnectionString;// 静态构造函数static Database(){// 从配置文件中读取连接字符串ConnectionString = ReadConnectionStringFromConfig();Console.WriteLine("数据库连接字符串已初始化");}private static string ReadConnectionStringFromConfig(){// 模拟从配置文件读取连接字符串的过程return "Server=localhost;Database=MyDB;User=sa;Password=123456";}
}

静态构造函数的特点：

不能有访问修饰符和参数。
在类被加载时自动调用，且只调用一次。
主要用于初始化静态字段。

三、常量和静态量

常量和静态量（静态字段）在某些方面很相似，但实际上它们有着本质的区别。了解这些区别，可以帮助我们在编程时做出正确的选择。

常量 vs 静态常量

常量（const）和静态常量（static readonly）都表示“不可变”的值，但它们的实现方式不同：

常量：在编译时就确定值，并且在整个程序运行过程中都不能改变。常量的值会直接嵌入到使用它的代码中。
静态常量：在运行时初始化，一旦初始化后就不能再改变。静态常量的值存储在内存中，通过引用访问。

class ConstantsDemo
{// 常量public const double Pi = 3.14159;// 静态常量public static readonly double E = 2.71828;// 静态常量可以在静态构造函数中初始化static ConstantsDemo(){E = CalculateE(); // 假设CalculateE是一个计算e的方法}// 常量必须在声明时赋值// public const double Tau = 2 * Pi; // 正确// public const double RandomValue = new Random().Next(); // 错误，编译时无法确定值
}

何时使用常量，何时使用静态常量？

使用常量：当值在编译时就已知，并且不会改变时，如数学常数、配置参数等。
使用静态常量：当值需要在运行时计算或初始化时，如从配置文件读取的值、通过复杂计算得到的值等。

四、分布类和分布方法

在大型项目中，一个类可能会变得非常庞大，难以管理。C#提供了分布类和分布方法的特性，允许我们将一个类的定义分散到多个文件中，提高代码的可维护性。

分布类：拆分类的定义

分布类使用partial关键字声明，允许将类的定义分散到多个文件中：

// 文件1：Car.cs
public partial class Car
{public string Color { get; set; }public string Model { get; set; }public void Start(){Console.WriteLine("汽车启动了");}
}// 文件2：Car_Extensions.cs
public partial class Car
{public void Accelerate(){Console.WriteLine("汽车加速了");}public void Brake(){Console.WriteLine("汽车刹车了");}
}

虽然Car类的定义分布在两个文件中，但在编译时它们会被视为一个完整的类。

分布方法：拆分方法的实现

分布方法是分布类的一种特殊情况，它允许将方法的定义和实现分开：

// 文件1：Car.cs
public partial class Car
{public partial void OnStart(); // 分布方法声明public void Start(){Console.WriteLine("汽车启动了");OnStart(); // 调用分布方法}
}// 文件2：Car_Extensions.cs
public partial class Car
{// 分布方法实现partial void OnStart(){Console.WriteLine("启动事件触发");}
}