这是本文档旧的修订版！

# 一、什么时候应该用嵌套类（C# 示例）

## 1. 嵌套类是外部类的组成部分 例如 `Person.Address` 很自然地属于 Person。

```csharp public class Person {

  public string Name { get; }
  public Address HomeAddress { get; }

  public Person(string name, Address homeAddress)
  {
      Name = name;
      HomeAddress = homeAddress;
  }

  public class Address  // 嵌套类
  {
      public string City { get; }
      public string Street { get; }

      public Address(string city, string street)
      {
          City = city;
          Street = street;
      }
  }

} ```

使用理由 - Address 不会被其他模块独立使用 - 内聚性更强 - 隐藏实现细节

—

## 2. 嵌套类作为外部类的辅助器（例如 builder 或 iterator）

```csharp public class User {

  public string Name { get; }
  public int Age { get; }

  private User(string name, int age)
  {
      Name = name;
      Age = age;
  }

  public class Builder
  {
      private string _name;
      private int _age;

      public Builder SetName(string name)
      {
          _name = name;
          return this;
      }

      public Builder SetAge(int age)
      {
          _age = age;
          return this;
      }

      public User Build()
      {
          return new User(_name, _age);
      }
  }

} ```

使用理由 - Builder 的存在意义仅服务 User - 避免污染全局命名空间

—

## 3. 非静态嵌套类需要访问外部类成员 （C# 的嵌套类默认 *不* 自动持有外部类实例，需要你传入）

```csharp public class Machine {

  private int _state = 0;

  public class Handler
  {
      private readonly Machine _machine;

      public Handler(Machine machine)
      {
          _machine = machine;
      }

      public void Increase()
      {
          _machine._state++;
      }
  }

} ```

使用理由 - Handler 的功能依赖 Machine 的状态 - 嵌套使结构更清晰

—

# 二、什么时候不应该用嵌套类（C# 示例）

## 1. 内部类可能被多个外部模块复用 这会导致奇怪的层级结构。

```csharp public class Order {

  public class MathUtils  // 不应该嵌套
  {
      public static int Add(int a, int b) => a + b;
  }

} ```

错误原因 - MathUtils 与 Order 毫无关系 - 应该独立成为工具类

—

## 2. 嵌套类生命周期与外部类不一致 例如：后台任务会比外部类活得更久。

```csharp public class Controller {

  public class BackgroundWorker  // 不应该是非静态嵌套类
  {
      // 可能会导致持有外部类引用过久（如果你传进来）
  }

} ```

如果 BackgroundWorker 长期运行，而你在其中引用了 Controller，就会阻止 Controller 被回收。

解决方式 - 不把长期对象设计为嵌套类 - 或使用静态/独立类 + 弱引用

—

## 3. 嵌套层级太深影响可读性

```csharp public class A {

  public class B
  {
      public class C
      {
          public class D { }
      }
  }

} ```

没有明确业务意义时应避免这种结构。

—

## 4. 内部类与外部类逻辑关系不强 例如：

```csharp public class Company {

  public class Logger  // 不应该嵌套
  {
      public void Log(string message) => Console.WriteLine(message);
  }

} ```

Logger 并不是 Company 的组成部分，应该是独立工具类。

—

# 总结（C# 场景）

应该用嵌套类当： - 逻辑上只属于外部类 - 属于外部类的组成部分 - 辅助外部类工作 - 更强的封装性和结构清晰度

不应该用嵌套类当： - 类具有可复用性 - 生命周期与外部类不一致 - 业务上没有强逻辑归属 - 过深层级影响可读性

—