w wyl123ly 的博客
MD

CSharp-02-面向对象

52 KB 2026.10.11 原文件

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.MemberType.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() 的执行过程:

  1. 取 s 的对象头里的方法表指针;
  2. 按固定槽位索引在表里查到 Area 的地址;
  3. 跳转执行(间接调用)。

代价与优化:

  • 代价:一次间接跳转,且阻止内联(编译器不知道目标是谁),分支预测器可能猜错。
  • 优化一:去虚化(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、ShapeIDisposable、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 结构体与类的区别

维度structclass
类型值类型引用类型
赋值复制全部字段复制引用
默认 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 —— 值类型比较,无装箱
对比项classrecord(引用类型)record structstruct
相等语义引用相等(除非重写)值相等(自动生成)值相等逐字段反射比较(慢)
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 就是靠它实现的)。

三条定义规则:

  1. 必须定义在非嵌套、非泛型的静态类里;
  2. 方法必须是 static;
  3. 第一个参数带 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 只给调试:不要拿它做序列化或业务判断,给它一个稳定的、人类可读的格式就够了。


六、练习题

  1. 基础题:写一个 Temperature 类,要求:构造函数接收摄氏度并校验不低于 ;提供只读属性 Celsius、计算属性 Fahrenheit、Kelvin;实现 ToString() 返回 "25.0°C / 77.0°F"。
  2. 基础题:定义一个 [Flags] enum Permissions { None=0, Read=1, Write=2, Delete=4, All=Read|Write|Delete },用扩展方法 Has(this Permissions p, Permissions flag) 实现权限判断(注意 None 的语义),并写 3 条断言验证。
  3. 进阶题:把下面的类改造成不可变设计,并解释每处改动的原因:

```csharp

public class Config { public string Url; public List<string> Headers = new(); public int Timeout; }

```

要求:Timeout 只允许 ;Headers 外部只能读;提供 with 风格的 WithTimeout(int) 方法;实现值相等性。

  1. 进阶题:实现 sealed class CsvWriter : IDisposable,构造时打开文件并写入表头,WriteRow(params string[] cells) 转义逗号与双引号,Dispose 时关闭流。要求多次 Dispose 安全,并在 WriteRow 里对已释放状态抛 ObjectDisposedException。再用 using 声明调用它。
  2. 思考题: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 的类、继承、魔术方法做对比

参考来源