SOLID 原则与 C#

Source: Dev.to

在软件开发中，SOLID 原则——由 Robert C. Martin 定义——是五条基本准则，帮助创建灵活、可读且易于维护的面向对象系统。在 C# 中，这些原则通常被用作类设计的规则。

单一职责原则 (SRP)

一个类应该只有一个职责，即只有一个导致它变化的原因。当一个类执行多个任务（例如，保存数据和生成报告）时，维护起来会更困难，且更容易出错。

// 错误示例：同时处理保存订单和打印发票
public class OrderManager
{
    public void SaveOrder(Order order) { /* save */ }
    public void PrintInvoice(Order order) { /* print */ }
}

// 正确示例：每个类只承担单一职责
public class OrderRepository
{
    public void Save(Order order) { /* save */ }
}

public class InvoicePrinter
{
    public void Print(Order order) { /* print */ }
}

开放/封闭原则 (OCP)

类应该 对扩展开放，但 对修改封闭。应当在不更改已有类代码的情况下添加新行为，通常通过使用抽象类或接口来实现。

// Wrong: Adding a new payment method requires modifying the class
public class PaymentService
{
    public void Pay(string type)
    {
        if (type == "CreditCard") { /* ... */ }
        else if (type == "PayPal") { /* ... */ }
    }
}

// Correct: Adding a new method requires creating a new class
public interface IPayment
{
    void Pay();
}

public class CreditCardPayment : IPayment
{
    public void Pay() { /* ... */ }
}

public class PayPalPayment : IPayment
{
    public void Pay() { /* ... */ }
}

里氏替换原则 (LSP)

派生类必须能够替代它们的基类。子类应当在任何期望基类的地方都能正常工作，且不能破坏基类的契约。

public abstract class Bird
{
    public abstract void Fly();
}

public class Sparrow : Bird
{
    public override void Fly() => Console.WriteLine("Sparrow is flying");
}

// 错误示例：企鹅不会飞，但被迫实现 Fly()
public class Penguin : Bird
{
    public override void Fly() => throw new NotImplementedException();
}

Penguin 类违反了 LSP，因为 Bird 抽象假设所有鸟都会飞。更好的设计是将会飞和不会飞的鸟分别抽象为不同的接口，例如 IFlyingBird 和 INonFlyingBird。

接口分离原则 (ISP)

客户端不应被迫依赖它们不使用的接口。应优先使用小而专注的接口，而不是庞大、“臃肿”的接口。

// 错误：所有动物都被迫实现走、飞、游
public interface IAnimal
{
    void Walk();
    void Fly();
    void Swim();
}

// 正确：拆分为更小的接口
public interface IWalkable { void Walk(); }
public interface IFlyable { void Fly(); }
public interface ISwimmable { void Swim(); }

public class Dog : IWalkable, ISwimmable
{
    public void Walk() { /* ... */ }
    public void Swim() { /* ... */ }
}

依赖倒置原则 (DIP)

高层模块不应该依赖低层模块；两者都应该依赖抽象（接口或抽象类）。该原则是依赖注入的基础。

// Wrong: Service depends directly on a concrete logger
public class Service
{
    private readonly ConsoleLogger _logger = new ConsoleLogger();
}

// Correct: Service depends on an abstraction
public interface ILogger
{
    void Log(string msg);
}

public class ConsoleLogger : ILogger
{
    public void Log(string msg) => Console.WriteLine(msg);
}

public class Service
{
    private readonly ILogger _logger;
    public Service(ILogger logger) => _logger = logger;
}

应用 SOLID 的好处

• 提高代码可读性和可维护性
• 构建更能抵御变化的架构
• 简化单元测试
• 减少代码重复并提升可复用性

原则概述

• SRP – 一个类应该只有一个职责。
• OCP – 对扩展开放，对修改关闭。
• LSP – 子类必须能够替代其基类。
• ISP – 倾向使用小而专注的接口。
• DIP – 依赖抽象，而非具体实现。