**设计模式的原则是指导设计模式创建和应用的基本原则,这些原则有助于创建灵活、可维护且可扩展的软件系统。**
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#中实现这些原则,可以帮助我们更好地设计和构建应用程序。