CSharp-02-面向对象
这篇讲什么
C# 是一门面向对象(Object-Oriented Programming, OOP)语言,但它的 OOP 不是为了"显得高级":封装对应不变量保护,继承对应复用与扩展点,多态对应在运行时替换实现。本篇从"字段 vs 属性"这种最小的设计决策开始,一路讲到
record、IDisposable、运算符重载与object三件套的重写约定,每一条都回答同一个问题:它解决什么真实问题,不用它会怎样。阅读前提:CSharp-01-环境与基础语法(类型、值/引用语义、命名空间)。示例以 .NET SDK 10.0.401 / C# 13 为基准,版本差异处标注「以官方最新文档为准」。
一、是什么:封装、继承、多态在 C# 里的落点
| OOP 支柱 | 解决的问题 | C# 提供的机制 |
|---|---|---|
| 封装(Encapsulation) | 对象状态被外部随意改动导致不一致 | 访问修饰符、属性、readonly、init、只读集合 |
| 继承(Inheritance) | 复制粘贴式复用带来的维护地狱 | class : Base、virtual/override、abstract、sealed |
| 多态(Polymorphism) | 调用方不该知道具体实现 | 虚方法 + 虚方法表(vtable)、接口、泛型约束 |
| 抽象(Abstraction) | 只暴露契约、隐藏实现 | abstract class、interface、默认接口实现 |
C# 的一个特点是单继承 + 多接口:类只能继承一个基类,但可以实现任意多个接口。这避免了 C++ 的多重继承菱形问题,同时用接口保留"多能力组合"的表达力。
二、为什么这样设计
2.1 为什么用属性,而不是公共字段
公共字段 public int Age; 看起来最省事,但它把未来的修改成本埋进去了:
| 需求变化 | 公共字段 | 属性 |
|---|---|---|
| 想加范围校验 | 破坏性改动:所有调用方要改成 SetAge() | 在 set 里加校验,调用方零改动 |
| 想改成计算值 | 不可能(字段就是存储) | 改成 => ... 表达式体,零改动 |
| 想加日志/通知/懒加载 | 不可能 | 在访问器里做 |
| 想支持绑定(WPF/序列化) | 不支持(反射找属性) | 天然支持 |
| 二进制兼容性 | 改字段签名即破坏 ABI | 访问器是方法,可独立演进 |
结论:字段是私有的实现细节,属性是公开的契约。除了 private/internal 的内部数据载体和 const,公共成员一律用属性。
2.2 为什么有 init 和 required
不可变对象(immutable object)是并发安全与推理友好的基础,但用构造函数表达所有参数会很难写(参数一多就成了"参数爆炸")。init 让"只能在对象初始化阶段赋值"成为语法能力,required 则强制调用方必须写。
var cfg = new EndpointConfig { Host = "api.example.com", Port = 443 }; // 可读性接近字段初始化
// cfg.Host = "other"; // 编译错误:init 访问器只在初始化时可写
三、核心内容
3.1 类与对象
// 类 = 类型的定义(模板);对象 = 它的实例(在堆上)
public sealed class BankAccount
{
// 私有字段:只在本类可见,外部无法绕过校验改余额
private decimal _balance;
// 属性:对外契约。get 只读,set 私有 —— 外部只能通过 Deposit 修改
public string Owner { get; }
public decimal Balance => _balance; // 计算型属性,不占存储
public BankAccount(string owner, decimal initial = 0m)
{
// 构造期校验:让"非法对象"根本创建不出来(保护不变量)
if (string.IsNullOrWhiteSpace(owner))
throw new ArgumentException("户主不能为空", nameof(owner));
if (initial < 0)
throw new ArgumentOutOfRangeException(nameof(initial), "初始余额不能为负");
Owner = owner;
_balance = initial;
}
public void Deposit(decimal amount)
{
if (amount <= 0) throw new ArgumentOutOfRangeException(nameof(amount));
_balance += amount;
}
}
var acc = new BankAccount("阿伟", 100m);
acc.Deposit(50m);
Console.WriteLine($"{acc.Owner}: {acc.Balance}"); // 阿伟: 150
3.2 字段与属性:五种属性写法
| 写法 | 代码 | 何时用 |
|---|---|---|
| 字段 | private int _age; | 内部存储,不对外暴露 |
| 自动属性 | public int Age { get; set; } | 最常用,无附加逻辑 |
| 只读自动属性 | public int Age { get; } | 构造时赋值,之后不变 |
| 计算属性 | public bool IsAdult => Age >= 18; | 由其他状态派生 |
init 属性 | public int Age { get; init; } | 对象初始化器赋值,之后不可变 |
required 属性 | public required int Age { get; init; } | 强制调用方在创建时提供 |
| 带逻辑的属性 | public int Age { get => _age; set => _age = value < 0 ? 0 : value; } | 需要校验/转换 |
public class Profile
{
// 自动属性:编译器生成隐藏的 backing field
public string Name { get; set; } = "匿名"; // 默认值可在声明处给
// init:只能在对象初始化器或构造函数里赋值,之后只读
public DateOnly BirthDate { get; init; }
// required:编译期强制"必须显式初始化",取代"构造函数塞满参数"
public required string Id { get; init; }
// 属性可以有不同的访问级别:外部只读,内部可写
public int LoginCount { get; private set; }
public void RecordLogin() => LoginCount++;
}
// 对象初始化器:先调构造函数,再按顺序调用属性 set/init
var p = new Profile { Id = "u-001", BirthDate = new DateOnly(2000, 1, 1), Name = "阿伟" };
p.RecordLogin();
Console.WriteLine($"{p.Id} {p.Name} 登录 {p.LoginCount} 次");
// 编译错误示例(不要取消注释):
// var bad = new Profile { BirthDate = new DateOnly(2000,1,1) }; // 缺 Id → required 报错
// p.Id = "u-002"; // init 属性不能再赋值
属性初始化器的执行顺序
1. 字段/属性的声明处初始化器(按文本顺序)
2. 基类构造函数
3. 本类构造函数体
4. 对象初始化器(在构造函数返回之后执行,按书写顺序)
所以
init访问器里读到的其他属性可能还是默认值——不要依赖初始化器的执行顺序做交叉计算。
3.3 访问修饰符
| 修饰符 | 可见范围 | 典型用途 |
|---|---|---|
public | 任何程序集 | 公开 API |
private | 仅本类型(含嵌套类型) | 内部实现、字段 |
protected | 本类型 + 派生类型 | 为子类提供的扩展点 |
internal | 同一程序集 | 程序集内部协作,避免污染公开 API |
protected internal | 同一程序集或派生类型(并集) | 少见,库内部扩展点 |
private protected | 同一程序集且派生类型(交集) | 库内继承体系专用 |
file | 仅当前文件(C# 11+) | 源生成器产物、单文件辅助类型 |
public class Widget
{
public string Name { get; set; } = ""; // 谁都能读
private int _secret; // 只有本类
protected int Depth { get; set; } // 子类可访问
internal string ModuleName { get; set; } = ""; // 同程序集可见
protected internal void Hook() { } // 同程序集 或 子类
private protected void InternalHook() { } // 同程序集 且 子类
}
// file 修饰的类型只在当前文件可见:避免为了一个辅助类起一个奇怪的名字
file sealed class WidgetHelper
{
public static string Describe(Widget w) => $"Widget({w.Name})";
}
默认可见性
- 类型的默认可见性是
internal(不是public)。- 类成员的默认可见性是
private。- 接口成员默认
public,且不能写private以外的更严格修饰符(C# 8+ 允许private成员用于默认实现内部复用)。-
protected成员既构成本类的 API,也构成对所有子类的契约:改动它就等于破坏性变更,谨慎使用。
3.4 构造函数与对象初始化器
| 成员 | 语法 | 何时调用 | 用途 |
|---|---|---|---|
| 实例构造函数 | public C(...) | new C(...) 时 | 初始化实例状态、校验参数 |
| 无参构造函数 | public C() { } | new C() | 需要默认构造时显式声明 |
| 静态构造函数 | static C() { } | 类型首次被使用前,且仅一次 | 初始化静态字段、读配置 |
| 私有构造函数 | private C() { } | C.Create() 内部 | 阻止 new,强制走工厂 |
| 主构造函数(C# 12+) | class C(int x) | new C(1) | 简洁声明不可变数据 |
| 终结器(Finalizer) | ~C() { } | GC 回收前,不确定时机 | 仅用于释放非托管资源 |
public class Connection
{
private static readonly Dictionary<string, string> Aliases;
// 静态构造函数:没有访问修饰符、不能带参数、不能手动调用
// 适合做"只做一次"的初始化;抛异常会让类型永久不可用(TypeInitializationException)
static Connection()
{
Aliases = new Dictionary<string, string> { ["local"] = "127.0.0.1" };
}
public string Host { get; }
// 构造函数链:用 this(...) 复用默认值逻辑,避免重复校验代码
public Connection() : this("local", 5432) { }
public Connection(string host, int port)
{
if (port is < 1 or > 65535)
throw new ArgumentOutOfRangeException(nameof(port));
Host = Aliases.GetValueOrDefault(host, host);
Port = port;
}
public int Port { get; }
// 私有构造 + 静态工厂:语义清晰,且可返回缓存实例
private Connection(string host) : this(host, 5432) { }
public static Connection ForHost(string host) => new(host);
public override string ToString() => $"{Host}:{Port}";
}
Console.WriteLine(new Connection()); // local → 127.0.0.1:5432
Console.WriteLine(Connection.ForHost("db")); // db:5432
3.5 静态成员与静态构造函数
public static class MathEx // 静态类:不能实例化,只能放静态成员
{
public const double Epsilon = 1e-9; // 编译期常量
// 静态字段:整个类型一份,多线程共享 —— 可变静态状态是并发 bug 的温床
private static int _callCount;
public static int CallCount => _callCount;
public static bool NearlyEqual(double a, double b) => Math.Abs(a - b) < Epsilon;
}
// 静态成员用类型名访问,没有隐含的实例
Console.WriteLine(MathEx.NearlyEqual(0.1 + 0.2, 0.3));
| 对比项 | 实例成员 | 静态成员 |
|---|---|---|
| 归属 | 每个对象一份 | 类型一份 |
| 访问方式 | obj.Member | Type.Member |
| 能否访问实例成员 | 能 | 不能(没有 this) |
| 生命周期 | 随对象 | 随应用域/类型加载 |
| 线程安全 | 对象本身不共享则安全 | 共享,需同步或用不可变 |
静态构造函数与
beforefieldinit没有显式静态构造函数的类型会被标记
beforefieldinit,运行时可以在任意时刻(通常是第一次访问前)初始化静态字段,时机更宽松、性能更好。一旦你写了静态构造函数,运行时就被强制为"精确时机"语义,可能引入初始化顺序依赖。能用静态字段初始化器解决就别写静态构造函数。
3.6 继承:base、虚方法与重写、sealed
public abstract class Shape
{
public string Name { get; }
protected Shape(string name) => Name = name;
// 虚方法:给出默认实现,子类可(也可不)重写 —— 这就是多态的入口
public virtual double Area() => 0;
// 抽象方法:没有实现,子类必须重写
public abstract double Perimeter();
// 非虚方法:不允许子类改变行为,保护关键逻辑(如不变量检查)
public string Describe() => $"{Name}: 面积 {Area():F2},周长 {Perimeter():F2}";
}
public class Circle : Shape
{
private readonly double _r;
// 用 base(...) 把参数转交给基类构造函数:基类状态必须由基类自己初始化
public Circle(double r) : base("圆") => _r = r;
// override 要求签名完全一致;返回类型协变(C# 9+)允许返回更具体的类型
public override double Area() => Math.PI * _r * _r;
public override double Perimeter() => 2 * Math.PI * _r;
}
// sealed 类:不能被继承。用于
// 1) 明确关闭扩展点(安全、可推理) 2) 让 JIT 能去虚化(性能)
public sealed class Unit : Shape
{
public Unit() : base("单位") { }
public override double Area() => 1;
public override double Perimeter() => 4;
}
Shape[] shapes = [new Circle(1), new Unit()];
foreach (Shape s in shapes)
Console.WriteLine(s.Describe()); // 运行时才决定调用哪个 Area()
| 关键字 | 含义 | 子类可否改变行为 |
|---|---|---|
virtual | 有实现,可重写 | 可以(也可不重写) |
abstract | 无实现,必须重写 | 必须 |
override | 重写基类的虚/抽象成员 | 可以(除非加 sealed) |
sealed override | 重写了,但终止再重写 | 不可以 |
new | 隐藏基类成员(不是重写) | 取决于静态类型 —— 通常是 bug |
| (无修饰符) | 非虚方法 | 不可以 |
new隐藏成员是多态杀手```csharp
class A { public virtual string Who() => "A"; }
class B : A { public new string Who() => "B"; } // 隐藏,不是重写
A x = new B();
Console.WriteLine(x.Who()); // 输出 "A"!
```
因为
Who()不是虚调用,编译器按静态类型A绑定。这正是"为什么应该用override"的最有力证明。编译器会给出警告(CS0108),别忽略它。
3.7 多态的实现原理:虚方法表(vtable)
每个类型在加载时,运行时为其构建一张方法表(Method Table),其中包含该类型所有虚方法的实际入口地址。对象头里有一个指向自己类型方法表的指针。
对象实例 类型的方法表(Method Table / vtable)
┌──────────────┐ ┌──────────────────────────────┐
│ 同步块索引 │ │ Area() → Circle.Area │
│ 方法表指针 ───┼──────────►│ Perimeter() → Circle.Perim. │
│ 字段 _r │ │ ToString() → Object.ToString │
└──────────────┘ └──────────────────────────────┘
一次虚调用 s.Area() 的执行过程:
- 取
s的对象头里的方法表指针; - 按固定槽位索引在表里查到
Area的地址; - 跳转执行(间接调用)。
代价与优化:
- 代价:一次间接跳转,且阻止内联(编译器不知道目标是谁),分支预测器可能猜错。
- 优化一:去虚化(devirtualization)。JIT 若发现
s的实际类型唯一(如new Circle()后立即调用、或类型是sealed),就把虚调用改成直接调用甚至内联。 - 优化二:接口调用在 .NET 里有接口分发(interface dispatch)的专用缓存,比早期版本快很多。
- 关键结论:多态不是"免费的抽象",但在绝大多数代码里它的开销可以忽略;只有剖析(profiling)证明它是热点时才需要处理。
3.8 抽象类与接口:对比与选型
| 维度 | 抽象类(abstract class) | 接口(interface) |
|---|---|---|
| 继承数量 | 只能继承 1 个 | 可实现任意多个 |
| 能否有字段 | 能(实例状态) | 不能(C# 8+ 可有静态字段,但不能有实例字段) |
| 能否有构造函数 | 能 | 不能 |
| 成员实现 | 可以有具体方法(非抽象) | 默认实现可选(C# 8+ 默认接口成员) |
| 版本兼容性 | 加抽象成员会破坏所有子类 | 加默认实现的成员不破坏实现方 |
| 可见性 | 成员可 protected/internal | 成员默认 public |
| 语义 | "是一种(is-a)",共享实现 | "能做某事(can-do)",声明能力 |
| 典型例子 | Stream、Shape | IDisposable、IComparable<T>、IEnumerable<T> |
// 接口:只声明能力,不关心实现者是谁
public interface IShape
{
double Area();
// 默认接口实现(C# 8+):给已有接口"加成员而不破坏实现方"
// 注意:默认实现只能通过接口类型的引用调用,实现类的实例上不可见
string Describe() => $"面积 {Area():F2}";
}
public sealed class Square : IShape
{
private readonly double _side;
public Square(double side) => _side = side;
public double Area() => _side * _side;
}
IShape sq = new Square(3);
Console.WriteLine(sq.Area()); // 9
Console.WriteLine(sq.Describe()); // 面积 9.00(默认实现,需通过接口引用调用)
静态抽象接口成员(C# 11+)是另一件事:让接口能声明静态契约,供泛型算法使用——这是"零开销抽象"的基石。两个必须注意的点:返回类型要写成类型参数本身(写成接口名会报 CS8926),并且类型参数要构成自引用约束 where TSelf : IShape<TSelf>(也叫 F-bounded 约束)。
// 静态抽象成员:泛型算法可以直接调用 T.Unit,JIT 为每个 T 生成专用代码(无反射、无装箱)
public interface IShape<TSelf> where TSelf : IShape<TSelf>
{
double Area();
string Describe() => $"面积 {Area():F2}"; // 默认实现与静态抽象成员可以共存
static abstract TSelf Unit { get; } // 返回类型必须是 TSelf,不能写成 IShape<TSelf>
}
public sealed class Square : IShape<Square>
{
private readonly double _side;
public Square(double side) => _side = side;
public double Area() => _side * _side;
public static Square Unit => new Square(1); // 实现静态抽象成员
}
static T CreateUnit<T>() where T : IShape<T> => T.Unit; // 零开销:编译为对 T 静态方法的直接调用
IShape<Square> sq = new Square(3);
Console.WriteLine(sq.Describe()); // 面积 9.00
Console.WriteLine(CreateUnit<Square>().Area()); // 1
默认接口实现解决的真实痛点
你发布了一个
IRepository接口,几十个类实现了它。现在想加一个便捷方法GetOrNull(id)。传统接口做不到——加成员就会让所有实现类编译不过。默认接口实现允许你只加方法体就完成演进,实现方零改动。代价是:默认实现不能被实现类"继承"(只能通过接口引用调用),且它带来了一定的运行时成本(接口分发)。能改所有实现方时,仍然优先直接加成员。
选型建议:
- 需要共享状态或大量复用实现、且概念上确有"是一种"关系 → 抽象类。
- 只表达能力/契约,或一个类型需要多种能力 → 接口。
- 需要版本演进(库作者给已发布接口加成员)→ 接口 + 默认实现。
- 只有"数据 + 少量行为"且不需要继承 → 考虑
record或readonly struct。 - 不要为了复用代码而用继承:优先组合(composition)。继承是最强的耦合形式。
3.9 结构体与类的区别
| 维度 | struct | class |
|---|---|---|
| 类型 | 值类型 | 引用类型 |
| 赋值 | 复制全部字段 | 复制引用 |
默认 Equals | 逐字段比较 | 引用相等 |
能否为 null | 不能(T? 可以) | 可以 |
| 继承 | 不能继承、不能被继承(可实现接口) | 完全支持 |
| 参数传递 | 默认按值复制(in/ref 可避免) | 默认传引用 |
| 大小建议 | ≤ 16–24 字节,且不可变 | 无限制 |
| 分配位置 | 通常在栈,或内联在宿主里 | 托管堆 |
| 适用场景 | 小数据载体(坐标、范围、颜色、金额、ValueTuple) | 有身份、有生命周期、可能较大 |
// readonly struct:所有字段 readonly,编译器可据此优化(避免防御性复制)
public readonly struct Money : IEquatable<Money>
{
public decimal Amount { get; }
public string Currency { get; }
public Money(decimal amount, string currency)
{
Amount = amount;
Currency = currency ?? throw new ArgumentNullException(nameof(currency));
}
// 实现 IEquatable<T> 避免装箱,并明确相等语义(见 3.15)
public bool Equals(Money other) =>
Amount == other.Amount && string.Equals(Currency, other.Currency, StringComparison.Ordinal);
public override bool Equals(object? obj) => obj is Money m && Equals(m);
public override int GetHashCode() => HashCode.Combine(Amount, Currency);
public override string ToString() => $"{Amount} {Currency}";
public static Money operator +(Money a, Money b) =>
a.Currency == b.Currency
? new Money(a.Amount + b.Amount, a.Currency)
: throw new InvalidOperationException("币种不同,不能相加");
}
var a = new Money(10m, "CNY");
var b = new Money(5m, "CNY");
Console.WriteLine(a + b); // 15 CNY
Console.WriteLine((a + b).Equals(new Money(15m, "CNY"))); // True
可变结构体的经典陷阱
```csharp
struct Counter { public int Value; public void Inc() => Value++; }
var list = new List<Counter> { new Counter() };
list[0].Inc(); // 编译错误:不能修改返回的临时副本
var c = list[0]; c.Inc(); list[0] = c; // 必须这样写
```
List<T>的索引器返回副本,list[0].Inc()修改的是临时值。历史上这个坑也出现在foreach迭代变量上(C# 5 之前是可变副本,现在foreach变量默认只读)。结论:结构体一律做成不可变(readonly struct)。
3.10 枚举与 [Flags]
// 普通枚举:底层是整数,默认从 0 递增
public enum OrderStatus { Pending, Paid, Shipped, Cancelled }
// [Flags] 标志枚举:值必须是 2 的幂,可组合
[Flags]
public enum FileAccess : byte // 可指定底层类型:byte/sbyte/short/ushort/int/uint/long/ulong
{
None = 0,
Read = 1 << 0, // 1
Write = 1 << 1, // 2
Execute = 1 << 2, // 4
ReadWrite = Read | Write,
All = Read | Write | Execute,
}
var perm = FileAccess.Read | FileAccess.Write;
// HasFlag:注意它对"值为 0 的标志"总是返回 true,且早期实现有装箱开销
Console.WriteLine(perm.HasFlag(FileAccess.Write)); // True
Console.WriteLine((perm & FileAccess.Execute) != 0); // False(推荐写法,无装箱)
// ToString() 会优先匹配"名字完全等于该组合值"的成员,所以这里输出 ReadWrite 而不是 "Read, Write"
Console.WriteLine(perm); // ReadWrite(因为定义了 ReadWrite = Read | Write)
Console.WriteLine((int)perm); // 3
Console.WriteLine(Enum.TryParse<FileAccess>("read", true, out var parsed)); // True(忽略大小写)
| 使用要点 | 说明 | |
|---|---|---|
普通枚举不要用 [Flags] | 否则 ToString() 输出难以阅读 | |
标志枚举的 None = 0 | 表示"无标志",是组合运算的单位元 | |
用 & 判断、`\ | 组合、~` 取反 | 不要用 HasFlag 判断 0 值标志 |
ToString() 优先匹配已命名成员 | 定义了 `ReadWrite = Read \ | Write 时,perm.ToString() 给 ReadWrite 而非 "Read, Write"`;去掉这个复合成员才会看到分解结果 |
| 枚举值改数字会破坏持久化数据 | 数据库/JSON 里存了枚举的整数,重排值就是数据事故;显式赋值锁定 | |
| 枚举参与字符串转换有反射成本 | 热路径上考虑 switch 或缓存 | |
| 想给枚举成员加方法 | 用扩展方法(见 3.13) |
3.11 record 与 record struct
record 的核心是值相等性 + 非破坏性变更:两个 record 的所有属性相等就 ==,with 生成改了几个属性的新实例。
// record class(引用类型,但用值语义比较)
public record Person(string Name, int Age)
{
// 位置参数自动生成:构造、init 属性、Deconstruct、值相等、ToString、with
public string Display => $"{Name}({Age})";
}
// record struct:值类型 + 值相等(C# 10+)
public readonly record struct Point(double X, double Y);
var p1 = new Person("阿伟", 30);
var p2 = new Person("阿伟", 30);
Console.WriteLine(p1 == p2); // True —— 引用类型但按值比较
Console.WriteLine(p1); // Person { Name = 阿伟, Age = 30 }
// with 表达式:浅复制 + 覆盖部分属性,原对象不变
var p3 = p1 with { Age = 31 };
Console.WriteLine($"{p1.Age} → {p3.Age}"); // 30 → 31
// 解构(由位置参数自动生成)
var (name, age) = p3;
var a = new Point(1, 2);
var b = new Point(1, 2);
Console.WriteLine(a == b); // True —— 值类型比较,无装箱
| 对比项 | class | record(引用类型) | record struct | struct |
|---|---|---|---|---|
| 相等语义 | 引用相等(除非重写) | 值相等(自动生成) | 值相等 | 逐字段反射比较(慢) |
with 表达式 | 不支持 | 支持 | 支持 | 不支持 |
ToString | 类型名 | 自动打印所有属性 | 自动打印所有属性 | 类型名 |
解构 Deconstruct | 手写 | 位置参数自动生成 | 位置参数自动生成 | 手写 |
| 可继承 | 是 | 是(可 sealed) | 否 | 否 |
| 可变性 | 任意 | 属性默认 init | 属性默认 get/set(建议 readonly) | 任意 |
| 适合 | 有身份的对象 | DTO、事件、领域值 | 小坐标/区间 | 小数据载体 |
record的相等性是浅比较如果
record里有个List<int>属性,==比较的是引用,不是元素。需要深比较就自己重写Equals/GetHashCode。另外with也是浅复制:复制后两个实例仍共享同一个列表对象。
3.12 分部类与分部方法
分部(partial)让一个类型分散在多个文件,主要服务于:源生成器产出代码、大型类的职责拆分、设计器代码与手写代码分离。
// 文件 A:手写部分
public partial class ReportBuilder
{
private readonly List<string> _lines = new();
public void Add(string line) => _lines.Add(line);
// 分部方法:声明与实现分离。C# 9+ 可以带返回值与 out 参数
// 若没有实现,编译器会把调用点整个移除(零开销的钩子)
partial void OnAdded(string line);
public string Build()
{
OnAdded("build"); // 没有实现时这一行会被删掉
return string.Join(Environment.NewLine, _lines);
}
}
// 文件 B:生成/扩展部分
public partial class ReportBuilder
{
private int _count;
// 实现分部方法
partial void OnAdded(string line) => _count++;
public int Count => _count;
}
var rb = new ReportBuilder();
rb.Add("第一行");
Console.WriteLine($"{rb.Build()} / 计数 {rb.Count}"); // 第一行 / 计数 1
partial的边界- 所有部分必须同一程序集、同一命名空间、同一类型名,且
partial不能用在接口/枚举/委托上(接口和枚举不支持,record支持)。- 分部方法必须是
private(隐式),不能有访问修饰符(C# 9+ 允许public等修饰符,但此时必须有实现)。- 不要用它来把"上帝类"拆成多文件假装不大——文件数不改变耦合度。
3.13 扩展方法
扩展方法让你在不修改原类型、不继承的前提下为它添加方法(LINQ 就是靠它实现的)。
三条定义规则:
- 必须定义在非嵌套、非泛型的静态类里;
- 方法必须是
static; - 第一个参数带
this修饰符,且方法不能是ref struct相关特殊情形。
public static class StringExtensions
{
// 扩展方法:调用时 this 参数不出现在实参里
public static string Truncate(this string value, int maxLength)
{
ArgumentNullException.ThrowIfNull(value);
if (maxLength < 0) throw new ArgumentOutOfRangeException(nameof(maxLength));
return value.Length <= maxLength ? value : value[..maxLength] + "…";
}
// 给枚举加语义方法:枚举本身不能定义方法
public static bool Includes(this FileAccess value, FileAccess flag) => (value & flag) == flag;
// 泛型扩展 + 约束:对所有 IComparable 的值类型可用
public static T Clamp<T>(this T value, T min, T max) where T : IComparable<T>
{
if (value.CompareTo(min) < 0) return min;
return value.CompareTo(max) > 0 ? max : value;
}
}
Console.WriteLine("Hello, world".Truncate(7)); // Hello, …
Console.WriteLine(FileAccess.Read.Includes(FileAccess.Read)); // True
Console.WriteLine(15.Clamp(0, 10)); // 10
| 要点 | 说明 |
|---|---|
| 优先级低于实例方法 | 实例上已有同名方法时,实例方法胜出(可用它做"版本迁移") |
| 通过命名空间生效 | 所在命名空间没 using 就找不到扩展方法 |
| 不能访问私有成员 | 它只是语法糖的静态调用,不是真正的成员 |
对 null 调用不抛异常 | ((string)null!).Truncate(3) 能进入方法体 → 必要时自己 ThrowIfNull |
| 不要滥用 | 给 object/int 加一堆扩展方法会污染整个项目的补全列表 |
3.14 索引器
索引器让对象支持 obj[key] 语法,本质是名为 this 的参数化属性。
public class Matrix
{
private readonly double[,] _data;
public Matrix(int rows, int cols)
{
_data = new double[rows, cols];
Rows = rows; Cols = cols;
}
public int Rows { get; }
public int Cols { get; }
// 索引器:可以有多个参数(这里是行、列)
public double this[int row, int col]
{
get => _data[row, col];
set => _data[row, col] = value; // 也可以在这里做校验
}
// 只读索引器:支持 C# 8 的范围语法(matrix[1..3])
public double[] this[Range rows]
{
get
{
var (offset, length) = rows.GetOffsetAndLength(Rows);
var result = new double[length * Cols];
for (int i = 0; i < length; i++)
for (int j = 0; j < Cols; j++)
result[i * Cols + j] = _data[offset + i, j];
return result;
}
}
}
var m = new Matrix(3, 3);
m[1, 1] = 5;
Console.WriteLine(m[1, 1]); // 5
Console.WriteLine(m[0..2].Length); // 6(前两行)
索引器的设计约定
- 索引器里有副作用或昂贵计算时,考虑提供
TryGet风格的方法,避免"看起来是读取、实际很慢"。- 集合类型的索引器一般不返回可空;字典语义的索引器在键不存在时通常
throw KeyNotFoundException,并另配TryGetValue。-
IEnumerable<T>上也定义了ElementAt,但那是 的线性查找——别把它当索引器用。
3.15 object 的三个基本方法:ToString / Equals / GetHashCode
| 方法 | 默认行为 | 重写约定 |
|---|---|---|
ToString() | 返回类型全名 | 给调试/日志用的可读表示;不要用来做序列化或业务逻辑 |
Equals(object?) | 引用相等(值类型为逐字段反射比较) | 满足自反、对称、传递、一致性;同时实现 IEquatable<T> 避免装箱 |
GetHashCode() | 基于引用(值类型为第一个字段的组合) | 相等对象必须有相同哈希码;不等的对象哈希码应尽量分散 |
为什么重写 Equals 就必须重写 GetHashCode? 因为哈希容器(Dictionary、HashSet)先按哈希码定位桶,再在桶内用 Equals 比较:
public class UserId
{
public string Value { get; }
public UserId(string value) => Value = value;
public override bool Equals(object? obj) => obj is UserId other && Value == other.Value;
public override int GetHashCode() => Value.GetHashCode();
public override string ToString() => Value;
}
var a = new UserId("u-1");
var b = new UserId("u-1"); // 不同实例,逻辑相等
Console.WriteLine(a.Equals(b)); // True
Console.WriteLine(a.GetHashCode() == b.GetHashCode()); // True
// HashSet 只有一行代码,却同时依赖这两个方法:
var set = new HashSet<UserId> { a };
Console.WriteLine(set.Contains(b)); // True —— 哈希码一致 → 同桶 → Equals 判定相等
// 如果忘了重写 GetHashCode:a 和 b 哈希码不同,落在不同桶,
// Contains 直接返回 False,即使 Equals 说它们相等 —— 这就是"哈希容器静默失效"的经典 bug
| 哈希契约 | 要求 |
|---|---|
| 相等 → 同哈希 | 必须满足,否则哈希容器错乱 |
| 同哈希 ↛ 相等 | 允许(哈希冲突),此时靠 Equals 区分,只是性能退化 |
| 对象作为键期间不可变 | 键的字段一旦改变,哈希码就变了,字典再也找不到它 |
可变对象作字典键
```csharp
var dict = new Dictionary<UserId, int> { [a] = 1 };
// 如果 UserId.Value 是可变的,改完 Value 后:
// dict[a] → KeyNotFoundException(哈希码变了,桶变了)
// 而且键还留在原来的桶里 → 内存泄漏式的"幽灵条目"
```
字典键必须不可变:用
readonly字段、init属性,或直接用string/int/record。
3.16 IDisposable 与 using 声明
垃圾回收(Garbage Collection, GC)只管理托管内存,管不了文件句柄、网络连接、GDI 句柄、数据库连接。这些必须显式释放,这就是 IDisposable。
// 标准释放模式(Dispose Pattern):托管资源 + 非托管资源 + 终结器
public sealed class TempFileWriter : IDisposable
{
private FileStream? _stream;
private bool _disposed;
public TempFileWriter(string path)
{
// FileOptions.DeleteOnClose 让文件在句柄关闭时自动删除
_stream = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
}
public void Write(string text)
{
// 每次使用前检查:用法错误应该尽早失败,而不是写入一个已关闭的流
ObjectDisposedException.ThrowIf(_disposed, this);
var bytes = System.Text.Encoding.UTF8.GetBytes(text);
_stream!.Write(bytes);
}
public void Dispose()
{
if (_disposed) return; // 幂等:多次 Dispose 必须安全
_disposed = true;
_stream?.Dispose(); // 只需释放自己拥有的托管资源
_stream = null;
}
// 本类不持有非托管资源 → 不需要终结器,也不需要完整的 Dispose(bool) 模板
}
// using 语句(块):离开作用域就释放,即使抛异常
using (var w1 = new TempFileWriter(Path.GetTempFileName()))
{
w1.Write("hello");
}
// using 声明(C# 8+):离开所在作用域时释放,写法更扁平
static string WriteTemp()
{
using var w2 = new TempFileWriter(Path.GetTempFileName());
w2.Write("world");
return "ok";
} // 这里自动 Dispose
// using 也能用于实现了 Dispose 的非 IDisposable 类型(模式匹配 Dispose)
// 以及 ref struct(如 Span<T> 相关类型),这是 C# 8+ 的放宽
| 写法 | 释放时机 | 适用 |
|---|---|---|
using (...) { } | 块结束时 | 作用域就是块的边界 |
using var x = ...; | 所在方法/块结束时 | 方法体较长、想减少缩进 |
try/finally { x.Dispose(); } | 手动控制 | 需要在释放前后做特殊处理 |
await using | 异步释放(IAsyncDisposable) | DisposeAsync 要等 IO 完成 |
不写 using,靠 GC | 不确定(可能几分钟后) | 只有极少数"内存压力型"资源可以 |
三个真实的释放错误
1. 忘记
using:文件被占用、连接池耗尽。Windows 上表现为"文件正被另一个进程使用"。2. 在
using块外使用对象:var s = new StreamReader(p); using (s) {...} s.ReadLine();→ObjectDisposedException。3.
Dispose抛异常掩盖真实异常:using的释放发生在finally里,若它抛异常会顶掉原来的异常。释放逻辑尽量不抛(或用try/catch包住)。另外:
Dispose与终结器(~Ctor)不要混用除非你确实持有非托管资源(如SafeHandle之外的原生指针)。有终结器的对象会被提升到更高代,显著增加 GC 成本。
3.17 命名参数、可选参数与 nameof
// 可选参数必须是"编译期常量",且必须排在必需参数之后
public static string Format(string template, bool upper = false, int width = 0, string pad = " ")
{
string s = upper ? template.ToUpperInvariant() : template;
return width > s.Length ? s.PadLeft(width, pad[0]) : s;
}
// 命名参数:调用点自解释,也让"跳过中间可选参数"成为可能
Console.WriteLine(Format("hi", width: 5, pad: ".")); // ...hi
Console.WriteLine(Format(template: "hi", upper: true));// HI
// 位置参数必须在命名参数之前(C# 7.2+ 允许命名参数后跟位置参数,若位置正确)
Console.WriteLine(Format("hi", true, 4));
public class Customer
{
public string Name { get; set; } = "";
// nameof:取标识符的字符串,重构安全(改名不会漏)
public void Rename(string newName)
{
ArgumentException.ThrowIfNullOrWhiteSpace(newName);
Name = newName;
}
public void Validate()
{
// 对比:写死 "Name" 字符串 → 改名后 MVVM/序列化悄悄失效
throw new ArgumentException("名字非法", nameof(Name));
}
}
Console.WriteLine(nameof(Customer)); // Customer
Console.WriteLine(nameof(Customer.Name)); // Name(只取最后一段)
Console.WriteLine(nameof(System.Collections.Generic.List<int>)); // List
| 特性 | 关键限制 |
|---|---|
| 可选参数 | 值被编译进调用方:改默认值需重编译调用方(同 const 的陷阱) |
| 可选参数 | 只能是编译期常量、default、new T()(值类型)或 default(T) |
| 命名参数 | 与位置参数混用时,位置参数必须在前且顺序正确 |
nameof | 不求值,编译期直接变字符串常量,零运行时开销 |
nameof | 可用于参数、局部变量、类型、成员、泛型类型;不能用于方法组本身以外的表达式 |
四、怎么用:一个完整的领域模型示例
需求:实现一个小型订单模型,要求对象创建后不可变(除状态机允许的转换)、金额不允许为负、相等性按业务键判定、资源正确释放。
using System.Text;
namespace Demo.Orders;
public interface IOrderRepository
{
void Save(Order order);
}
// 状态用枚举,避免字符串魔法值
public enum OrderState { Created, Paid, Shipped, Cancelled }
// 值对象:readonly record struct + 运算符重载,表达"不可变金额"
public readonly record struct Money(decimal Amount, string Currency)
{
public static Money Cny(decimal amount) =>
amount < 0 ? throw new ArgumentOutOfRangeException(nameof(amount)) : new Money(amount, "CNY");
public static Money operator +(Money a, Money b) =>
a.Currency == b.Currency ? new Money(a.Amount + b.Amount, a.Currency)
: throw new InvalidOperationException($"币种不一致:{a.Currency}/{b.Currency}");
public override string ToString() => $"{Amount:0.00} {Currency}";
}
// 实体:有身份(Id 决定相等),行为通过方法暴露,状态由方法驱动
public sealed class Order : IEquatable<Order>
{
private readonly List<string> _items = new();
private OrderState _state = OrderState.Created;
public required string Id { get; init; } // required:创建时必须给
public Money Total { get; private set; } = Money.Cny(0);
public OrderState State => _state;
public IReadOnlyList<string> Items => _items; // 只读视图:外部不能 Add
public void AddItem(string sku, decimal price)
{
EnsureState(OrderState.Created, "只有创建态可以加商品");
ArgumentException.ThrowIfNullOrWhiteSpace(sku);
_items.Add(sku);
Total += Money.Cny(price);
}
public void Pay()
{
EnsureState(OrderState.Created, "只有创建态可以支付");
if (_items.Count == 0) throw new InvalidOperationException("空订单不能支付");
_state = OrderState.Paid;
}
private void EnsureState(OrderState expected, string message)
{
if (_state != expected)
throw new InvalidOperationException($"{message}(当前 {_state})");
}
// 实体的相等性按业务键(Id),而不是按所有字段
public bool Equals(Order? other) =>
other is not null && string.Equals(Id, other.Id, StringComparison.Ordinal);
public override bool Equals(object? obj) => Equals(obj as Order);
public override int GetHashCode() => StringComparer.Ordinal.GetHashCode(Id);
public override string ToString() =>
new StringBuilder().Append(Id).Append(' ').Append(_state).Append(' ').Append(Total).ToString();
}
// 用扩展方法给枚举加"状态机合法性"判断,避免把规则散落在各处
public static class OrderStateExtensions
{
public static bool IsFinal(this OrderState s) =>
s is OrderState.Shipped or OrderState.Cancelled;
}
调用与验证:
var order = new Order { Id = "O-1001" };
order.AddItem("SKU-A", 19.90m);
order.AddItem("SKU-B", 5.00m);
order.Pay();
Console.WriteLine(order); // O-1001 Paid 24.90 CNY
Console.WriteLine(order.State.IsFinal()); // False
Console.WriteLine(order.Items.Count); // 2
// 相等性:按 Id 判定,与实例无关
var same = new Order { Id = "O-1001" };
Console.WriteLine(order.Equals(same)); // True
Console.WriteLine(ReferenceEquals(order, same)); // False
try { order.AddItem("SKU-C", 1m); }
catch (InvalidOperationException ex) { Console.WriteLine(ex.Message); } // 只有创建态可以加商品(当前 Paid)
设计要点回顾:required 保证 Id 不会漏;IReadOnlyList<string> 暴露只读视图而不是 List<string>(避免外部绕过 AddItem 破坏 Total 的一致性);Money 是不可变值对象,越界在构造处就抛异常;Order 的相等性按业务键,而不是按全部字段。
五、注意事项与常见坑
面向对象里最容易踩的十二个坑
1. 公共字段:以后加校验就是破坏性改动。公共成员一律属性。
2.
new隐藏成员而非override:多态失效,A x = new B()调到的是A的实现。3. 在构造函数里调用虚方法:基类构造函数执行时子类字段还是默认值,虚方法可能读到未初始化状态(经典 NPE/0 值 bug)。
4. 可变结构体:
list[0].Inc()改的是副本。结构体一律readonly struct。5. 重写
Equals忘了GetHashCode:HashSet/Dictionary静默失效。6. 用可变对象作字典键:改字段后键"消失",还留下幽灵条目。
7. 静态可变状态:多线程下是数据竞争,测试之间还会互相污染。
8.
record的浅比较:含集合属性时==比的是集合引用。9. 忘了
Dispose:文件占用、连接池耗尽;Dispose前的对象要判_disposed。10. 可选参数默认值写死在调用方:改了默认值不重编译调用方不生效(同级
const陷阱)。11.
[Flags]枚举用 0 值判断:perm.HasFlag(FileAccess.None)永远true。12. 用继承做代码复用:优先组合。继承是最强耦合——基类一改,所有子类都得跟着改。
设计上的实践建议
- 默认
sealed:不确定要不要被继承时先sealed,需要时再打开。开启扩展点是成本,不是收益。- 默认不可变:属性用
get/init,集合暴露IReadOnlyList<T>。不可变对象天然线程安全、可安全缓存。- 构造即校验:让非法状态根本无法构造,比让每个方法都要判合法性要可靠得多。
- 小接口:接口按能力划分(
IReadOnlyList而非"万能集合接口"),实现方负担低、mock 也容易。- 优先组合 + 依赖注入:见 后端-03-ASPNET-Core 的依赖注入实践。
-
ToString只给调试:不要拿它做序列化或业务判断,给它一个稳定的、人类可读的格式就够了。
六、练习题
- 基础题:写一个
Temperature类,要求:构造函数接收摄氏度并校验不低于 ;提供只读属性Celsius、计算属性Fahrenheit、Kelvin;实现ToString()返回"25.0°C / 77.0°F"。 - 基础题:定义一个
[Flags] enum Permissions { None=0, Read=1, Write=2, Delete=4, All=Read|Write|Delete },用扩展方法Has(this Permissions p, Permissions flag)实现权限判断(注意None的语义),并写 3 条断言验证。 - 进阶题:把下面的类改造成不可变设计,并解释每处改动的原因:
```csharp
public class Config { public string Url; public List<string> Headers = new(); public int Timeout; }
```
要求:Timeout 只允许 ;Headers 外部只能读;提供 with 风格的 WithTimeout(int) 方法;实现值相等性。
- 进阶题:实现
sealed class CsvWriter : IDisposable,构造时打开文件并写入表头,WriteRow(params string[] cells)转义逗号与双引号,Dispose时关闭流。要求多次Dispose安全,并在WriteRow里对已释放状态抛ObjectDisposedException。再用using声明调用它。 - 思考题:
abstract class与interface都能定义契约。请给出两个必须用抽象类、两个必须用接口的具体场景,并解释在 C# 8 引入默认接口实现之后,抽象类是否还有不可替代的价值。提示:从实例字段、构造函数、protected成员、多重实现四个角度考虑。
七、常见问题(FAQ)
Q1:属性和字段在运行时有什么区别?性能一样吗?
A:自动属性会被编译成"一个私有字段 + get_/set_ 方法",调用是方法调用,但因为通常极短,JIT 会内联,运行时开销与字段访问几乎无差。区别在于:字段可以 ref 传递、可以作为 const 语义、可以出现在 Interlocked 里;属性可以有逻辑、可以只读、可以参与接口。性能不是选字段的理由,语义才是。
Q2:什么时候该用 record,什么时候该用普通 class?
A:record 适合数据为中心、按值判断相等的类型:DTO、消息、事件、坐标、配置片段。普通 class 适合有身份和生命周期的类型:Order、HttpClient、DbContext——它们的相等性通常按业务键(如 Id)而不是全部字段,而且状态会变化。一个实用判据:如果两个实例所有字段相同你就认为它们"是同一个东西",用 record。
Q3:sealed 到底有什么好处?为什么微软的指南建议默认 sealed?
A:三点。(1)可推理:没人能改变行为,你能放心地读代码。(2)性能:JIT 对 sealed 类型的虚调用可以去虚化甚至内联。(3)演进自由:不 sealed 就意味着所有 virtual/protected 成员都是公开契约,以后不能随便改。反过来,sealed 挡住了框架作者没想到的扩展场景——所以对库的公共扩展点要谨慎 sealed,对应用内部类型可以放心 sealed。
Q4:IDisposable 的对象不 Dispose,GC 会帮我回收吗?
A:会回收内存,但不会及时回收非托管资源。FileStream 不释放时,文件句柄会一直占着直到终结器运行(时机不确定,可能要等一次完整 GC),期间别的进程打不开这个文件。所以规则是:实现了 IDisposable 的对象,创建者必须负责释放——用 using 声明,或把所有权转移给一个明确的生命周期容器(如 DI 容器的 scoped 服务)。
相关笔记
- CSharp-01-环境与基础语法:类型系统、值/引用语义、装箱与类型转换
- CSharp-03-集合与LINQ:
Equals/GetHashCode在哈希容器中的实际作用,迭代器与泛型约束 - CSharp-04-委托事件与Lambda:把方法当参数传递,扩展方法与 LINQ 的基础
- CSharp-06-现代CSharp特性:模式匹配、可空引用类型、
Span<T>与源生成器 - Python-04-面向对象:与 Python 的类、继承、魔术方法做对比
参考来源
- Properties
requiredmodifier- Access modifiers
- Constructors
- Object and collection initializers
- Static constructors
- Polymorphism
- Abstract and sealed classes and class members
- Interfaces
structtype- Records
- Partial classes and methods
- Extension methods
- Indexers
- Operator overloading
- Equality operators (design guidelines)
Object.GetHashCodeIDisposable- Garbage collection fundamentals
- Named and optional arguments
- 说明:C# 语言版本特性(如
required、静态抽象接口成员)随版本演进,以官方最新文档为准。