当前位置：首页 > news >正文

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

news 2025/8/23 4:40:36

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

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() {// 轮子滚动的代码}
}