了解 SOLID 原则，包含 C# 代码示例

Chasen Liu

Dec 2, 2024 — 7 min read

solid-principles-for-csharp

SOLID 原则让开发者能够编写易于扩展的代码，并避免常见的编码错误。这些原则由 Robert C. Martin 提出，已成为面向对象编程的重要基础。

什么是 SOLID 原则？

SOLID 是五个设计原则的缩写，分别代表：

S - 单一职责原则（Single Responsibility Principle，SRP）
O - 开闭原则（Open/Closed Principle，OCP）
L - 里氏替换原则（Liskov Substitution Principle，LSP）
I - 接口隔离原则（Interface Segregation Principle，ISP）
D - 依赖倒置原则（Dependency Inversion Principle，DIP）

这些原则旨在帮助开发者编写结构良好、灵活性高、便于扩展和维护的代码。

1. 单一职责原则（SRP）

定义： 一个类应该只有一个变化的原因，即它应该只有一个职责。

核心思想： 一个类应该只做一件事，并且要把这件事做好。这样可以确保代码更易理解和维护，因为职责单一的类变更的影响面较小。

现实类比： 想象你家中的电灯开关，它的职责只是控制灯的开和关。你不会希望这个开关还能控制其他家电，这样会增加复杂度并可能导致误操作。

代码示例：

在应用 SRP 之前，HomeDevice 类负责控制灯和电视，职责不够单一：

public class HomeDevice
{
    public void ControlLight() { }
    public void ControlTV() { }
}

改进后：

public class LightSwitch
{
    public void ControlLight() { }
}

public class TVRemote
{
    public void ControlTV() { }
}

解释： 改进后的设计中，LightSwitch 类只负责控制灯，而 TVRemote 类专门负责控制电视。这样，每个类都有单一的职责，减少了更改一个功能时影响另一个功能的风险。

2. 开闭原则（OCP）

定义： 类应该对扩展开放，对修改封闭。

核心思想： 一旦一个类写好，它应该允许扩展新功能，而不需要修改现有代码。这样能够降低因为改动已有代码而引入的潜在错误。

现实类比： 就像在汽车上加装新设备，你可以通过在车上加装新的附件（比如 GPS 或行车记录仪）来扩展功能，而不需要改变汽车的内部结构。

代码示例：

在应用 OCP 之前，CarFeature 类只能支持添加空调功能，如果想添加其他功能，需要修改它的实现：

public class CarFeature
{
    public void AddAirConditioning() { }
}

改进后：

public interface ICarFeature
{
    void AddFeature();
}

public class AirConditioning : ICarFeature
{
    public void AddFeature()
    {
        // 添加空调的逻辑
    }
}

public class GPS : ICarFeature
{
    public void AddFeature()
    {
        // 添加 GPS 的逻辑
    }
}

解释： 通过引入 ICarFeature 接口，可以通过实现 ICarFeature 来扩展新的功能，而无需更改原有代码。这符合开闭原则，使得代码更具扩展性。

3. 里氏替换原则（LSP）

定义： 父类的对象应能被其子类替换，而不影响程序的正确性。

核心思想： 子类在替代父类时，应该不会影响父类的行为。这可以让子类能在任何使用父类的地方正常工作。

现实类比： 想象你有一个通用的充电器接口，任何符合该接口标准的设备（如手机、平板）都可以使用这个充电器，而不需要考虑它们的具体型号。

代码示例：

在应用 LSP 之前，Device 类的充电方法不适用于某些设备：

public class Device
{
    public virtual void Charge() { /* 通用充电逻辑 */ }
}

public class SpecialDevice : Device
{
    public override void Charge()
    {
        throw new NotImplementedException("该设备不能使用通用充电方式！");
    }
}

改进后：

public interface IChargeable
{
    void Charge();
}

public class StandardDevice : IChargeable
{
    public void Charge()
    {
        // 实现通用充电逻辑
    }
}

public class SpecialDevice
{
    public void UseSpecialCharger()
    {
        // 实现特殊充电逻辑
    }
}

解释： 通过将 Charge 从 Device 中分离，我们避免了不适用于所有子类的问题，这样可以让代码更加合理且符合 LSP。

4. 接口隔离原则（ISP）

定义： 类不应被强制实现不需要的接口。

核心思想： 接口应当小而专注，类只需要实现它们真正需要的接口，这样可以减少冗余。

现实类比： 就像在咖啡店点单，你可以根据自己的喜好点咖啡和甜点，而不是被强迫必须点所有的东西。

代码示例：

在应用 ISP 之前，Worker 类必须实现 Eat 方法，即使机器人不需要吃饭：

public interface IWorker
{
    void Work();
    void Eat();
}

public class Robot : IWorker
{
    public void Work() { }
    public void Eat() { throw new NotImplementedException(); }
}

改进后：

public interface IWorkable
{
    void Work();
}

public interface IEatable
{
    void Eat();
}

public class Human : IWorkable, IEatable
{
    public void Work() { }
    public void Eat() { }
}

public class Robot : IWorkable
{
    public void Work() { }
}

解释： 通过分离接口，可以让 Robot 类只实现 IWorkable 接口，避免不必要的 Eat 方法，符合接口隔离原则。

5. 依赖倒置原则（DIP）

定义： 高层模块不应依赖低层模块，二者都应依赖于抽象。抽象不应依赖于细节，细节应依赖于抽象。

核心思想： 通过依赖抽象而不是具体实现，可以使代码更加松耦合，便于扩展和维护。

现实类比： 就像电器插入插座，插座只关心插头的形状，而不是具体电器的类型。只要插头符合标准，插座就可以为任何设备供电。

代码示例：

在应用 DIP 之前，Switch 类直接依赖具体的 LightBulb 类：

public class LightBulb
{
    public void TurnOn() { /* 实现 */ }
    public void TurnOff() { /* 实现 */ }
}

public class Switch
{
    private LightBulb bulb;
  
    public Switch(LightBulb bulb)
    {
        this.bulb = bulb;
    }

    public void Toggle()
    {
        if (bulb.IsOn)
            bulb.TurnOff();
        else
            bulb.TurnOn();
    }
}

改进后：

public interface ISwitchable
{
    void TurnOn();
    void TurnOff();
}

public class LightBulb : ISwitchable
{
    public void TurnOn() { }
    public void TurnOff() { }
}

public class Switch
{
    private ISwitchable device;

    public Switch(ISwitchable device)
    {
        this.device = device;
    }

    public void Toggle()
    {
        if (device is LightBulb bulb && bulb.IsOn)
            device.TurnOff();
        else
            device.TurnOn();
    }
}

解释： 通过引入 ISwitchable 接口，Switch 类依赖于抽象的接口，而不是具体实现，从而实现了 DIP。