C#入门理解设计模式的6大原则

**设计模式的原则是指导设计模式创建和应用的基本原则，这些原则有助于创建灵活、可维护且可扩展的软件系统。**

1. 单一职责原则（Single Responsibility Principle, SRP）

单一职责原则指出一个类应该只有一个引起它变化的原因。换句话说，一个类应该只负责一项职责。

// 违反SRP的例子：一个类负责两个职责
public class Employee {
    public string Name { get; set; }
    public void SaveEmployeeDetails() {
        // 保存员工详细信息的代码
    }
    public void SendEmail(string message) {
        // 发送电子邮件的代码
    }
}

// 遵循SRP的例子：将职责分离成不同的类
public class Employee {
    public string Name { get; set; }
}

public class EmailService {
    public void SendEmail(string message) {
        // 发送电子邮件的代码
    }
}

2. 开放封闭原则（Open/Closed Principle, OCP）

开放封闭原则表明软件实体（类、模块、函数等）应该对扩展开放，对修改封闭。

// 违反OCP的例子：通过修改现有类来添加新功能
public class ReportGenerator {
    public string GenerateReport() {
        // 报告生成的代码
        return "Report generated";
    }
    public string GenerateDetailedReport() {
        // 修改现有代码以生成详细报告
        return "Detailed report generated";
    }
}

// 遵循OCP的例子：通过扩展来添加新功能
public class ReportGenerator {
    public string GenerateReport() {
        // 报告生成的代码
        return "Report generated";
    }
}

public class DetailedReportGenerator : ReportGenerator {
    public override string GenerateReport() {
        // 新的详细报告生成代码
        return "Detailed report generated";
    }
}

3. 里氏替换原则（Liskov Substitution Principle, LSP）

里氏替换原则指出，子类型必须能够替换它们的基类型。这意味着在软件系统中，一个基类的对象可以被其子类的对象替换，而不影响系统的正确性。

// 里氏替换原则示例
public abstract class Shape
{
    public abstract double GetArea();
}

public class Circle : Shape
{
    private double _radius;
    public Circle(double radius) => _radius = radius;
    public override double GetArea() => Math.PI * _radius * _radius;
}

public class Rectangle : Shape
{
    private double _width, _height;
    public Rectangle(double width, double height) 
        => (_width, _height) = (width, height);
    public override double GetArea() => _width * _height;
}

// 可以在任何需要Shape的地方安全地使用Circle或Rectangle

4. 接口隔离原则（Interface Segregation Principle, ISP）

接口隔离原则强调应该避免创建过于庞大的接口。相反，应该创建多个专门的接口，每个接口只包含特定的功能。

// 违反ISP的例子：一个庞大的接口，要求实现所有方法
public interface IShape {
    void Draw();
    void Resize();
    void Move();
    // 其他与形状无关的方法...
}

// 遵循ISP的例子：分离成多个专门的接口
public interface IDrawable {
    void Draw();
}

public interface IResizable {
    void Resize();
}

public class Circle : IDrawable, IResizable {
    public void Draw() {
        // 画圆的代码
    }

    void IResizable.Resize() {
        // 调整大小的代码
    }
}

5. 依赖倒置原则（Dependency Inversion Principle, DIP）

依赖倒置原则指出高层模块不应该依赖于低层模块，它们都应该依赖于抽象。抽象不应该依赖于细节，细节应该依赖于抽象。

// 违反DIP的例子：高层模块依赖于低层模块
public class EmailService {
    private SMTPClient smtpClient = new SMTPClient();
    public void SendEmail(string message) {
        smtpClient.Send(message);
    }
}

// 遵循DIP的例子：依赖于抽象
public interface IEmailClient {
    void Send(string message);
}

public class EmailService {
    private IEmailClient emailClient;
    public EmailService(IEmailClient emailClient) {
        this.emailClient = emailClient;
    }
    public void SendEmail(string message) {
        emailClient.Send(message);
    }
}

public class SMTPClient : IEmailClient {
    public void Send(string message) {
        // 使用SMTP发送电子邮件的代码
    }
}

6. 组合/聚合复用原则（Composite/Aggregate Reuse Principle, CARP）

这个原则与DIP紧密相关，它建议优先使用对象的组合/聚合来达到复用的目的，而不是通过继承。

// 违反CARPR的例子：通过继承来复用
public class Vehicle {
    public void Move() {
        // 移动交通工具的代码
    }
}

public class Car : Vehicle {
    // 继承Vehicle，但Car可能有特殊的行为
    public override void Move() {
        // 汽车移动的代码
    }
}

// 遵循CARPR的例子：使用组合来复用
public class Vehicle {
    public virtual void Move() {
        // 移动交通工具的代码
    }
}

public class Car {
    private Engine engine;
    private Wheel[] wheels;
    
    public Car(Engine engine, Wheel[] wheels) {
        this.engine = engine;
        this.wheels = wheels;
    }
    
    public void Move() {
        engine.Start();
        foreach (var wheel in wheels) {
            wheel.Roll();
        }
    }
}

public class Engine {
    public void Start() {
        // 发动机启动的代码
    }
}

public class Wheel {
    public void Roll() {
        // 轮子滚动的代码
    }
}

编写代码时，需要灵活遵循这些原则，通过这些设计模式创建出更加灵活、可维护和可扩展的软件系统。在C#中实现这些原则，可以帮助我们更好地设计和构建应用程序。