掌握设计模式七大原则，提升代码质量

于 2025-05-20 09:00:00 发布
阅读量812 收藏 20
点赞数 27
分类专栏： 架构设计模式 C# 文章标签： 设计模式 单一职责原则 开闭原则 里氏替换原则 接口隔离原则 依赖倒置原则 迪米特法则
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/O_____V_____O/article/details/148040629
版权
#新星杯·14天创作挑战营·第11期#

文章目录

引言

设计模式是软件开发中解决常见问题的最佳实践方案，而设计原则则是指导这些模式的基本准则。良好的软件设计需要遵循一系列原则，这些原则能帮助我们创建更加灵活、可维护、可扩展的代码。本文将详细介绍设计模式的七大原则，并通过C#代码示例来解释这些原则的实际应用。

在软件设计中，这七大原则通常被称为"SOLID+两个"原则，其中SOLID是前五个原则的首字母缩写：

  • S：单一职责原则 (Single Responsibility Principle)
  • O：开闭原则 (Open-Closed Principle)
  • L：里氏替换原则 (Liskov Substitution Principle)
  • I：接口隔离原则 (Interface Segregation Principle)
  • D：依赖倒置原则 (Dependency Inversion Principle)

另外两个是：

  • 合成复用原则 (Composite Reuse Principle)
  • 迪米特法则 (Law of Demeter)

我们将依次探讨这些原则，并通过具体的C#代码示例来说明它们的应用。

1. 单一职责原则 (SRP)

1.1 原则定义

单一职责原则是指一个类应该只有一个引起它变化的原因。换句话说，一个类应该只负责一项职责，这样可以提高类的内聚性，降低类的耦合度。
单一职责原则
一个类
只有一个
引起变化的原因

1.2 示例说明

下面是一个违反单一职责原则的例子：

// 违反单一职责原则的示例
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Salary { get; set; }

    // 计算薪水的方法
    public decimal CalculateSalary()
    {
        return Salary;
    }

    // 保存员工信息到数据库
    public void SaveToDatabase()
    {
        // 保存逻辑...
        Console.WriteLine($"保存员工 {Name} 的信息到数据库");
    }

    // 生成员工报表
    public void GenerateReport()
    {
        // 报表生成逻辑...
        Console.WriteLine($"生成员工 {Name} 的报表");
    }
}

在上面的代码中，Employee类承担了多个职责：

  1. 管理员工基本信息
  2. 计算薪水
  3. 将数据保存到数据库
  4. 生成报表

应用单一职责原则后的代码：

// 遵循单一职责原则的示例

// 只负责员工基本信息
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public decimal Salary { get; set; }
}

// 负责薪水计算
public class SalaryCalculator
{
    public decimal CalculateSalary(Employee employee)
    {
        // 可能包含更复杂的薪水计算逻辑
        return employee.Salary;
    }
}

// 负责数据持久化
public class EmployeeRepository
{
    public void Save(Employee employee)
    {
        // 保存逻辑...
        Console.WriteLine($"保存员工 {employee.Name} 的信息到数据库");
    }
}

// 负责报表生成
public class ReportGenerator
{
    public void GenerateReport(Employee employee)
    {
        // 报表生成逻辑...
        Console.WriteLine($"生成员工 {employee.Name} 的报表");
    }
}

1.3 优势与应用场景

优势：

  • 提高代码的内聚性
  • 降低类之间的耦合
  • 提高代码的可读性与可维护性
  • 降低修改带来的风险

应用场景：

  • 当一个类承担的责任过多时
  • 当一个类因为多种不同原因而需要修改时
  • 当需要提高系统的模块化水平时

2. 开闭原则 (OCP)

2.1 原则定义

开闭原则是指软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。这意味着当需要增加新功能时，应该通过扩展现有代码而不是修改现有代码来实现。
开闭原则
对扩展开放
对修改关闭
通过继承或组合添加新功能
不修改现有代码

2.2 示例说明

下面是一个违反开闭原则的例子：

// 违反开闭原则的示例
public class Rectangle
{
    public double Width { get; set; }
    public double Height { get; set; }
}

public class Circle
{
    public double Radius { get; set; }
}

public class AreaCalculator
{
    public double CalculateArea(object shape)
    {
        // 需要修改此处代码来支持新的形状
        if (shape is Rectangle rectangle)
        {
            return rectangle.Width * rectangle.Height;
        }
        else if (shape is Circle circle)
        {
            return Math.PI * circle.Radius * circle.Radius;
        }
        
        throw new ArgumentException("不支持的形状类型");
    }
}

应用开闭原则后的代码：

// 遵循开闭原则的示例

// 定义形状接口
public interface IShape
{
    double CalculateArea();
}

// 实现矩形类
public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public double CalculateArea()
    {
        return Width * Height;
    }
}

// 实现圆形类
public class Circle : IShape
{
    public double Radius { get; set; }
    
    public double CalculateArea()
    {
        return Math.PI * Radius * Radius;
    }
}

// 面积计算器
public class AreaCalculator
{
    // 该方法不需要修改就能支持新的形状
    public double CalculateArea(IShape shape)
    {
        return shape.CalculateArea();
    }
}

// 如果需要添加新的形状，只需要实现IShape接口
public class Triangle : IShape
{
    public double Base { get; set; }
    public double Height { get; set; }
    
    public double CalculateArea()
    {
        return 0.5 * Base * Height;
    }
}

2.3 优势与应用场景

优势：

  • 提高代码的可扩展性
  • 降低维护成本
  • 提高系统的稳定性
  • 避免因修改现有代码而引入新的bug

应用场景：

  • 当预期系统需要经常添加新功能时
  • 当系统有稳定的抽象层时
  • 在设计框架和库时特别重要

3. 里氏替换原则 (LSP)

3.1 原则定义

里氏替换原则是指子类型必须能够替换其基类型。也就是说，程序中对父类的使用可以被其子类替换，而不会影响程序的正确性。
里氏替换原则
子类型
必须能够替换
基类型
不影响程序正确性

3.2 示例说明

下面是一个违反里氏替换原则的例子：

// 违反里氏替换原则的示例
public class Bird
{
    public virtual void Fly()
    {
        Console.WriteLine("鸟儿飞行");
    }
}

// 企鹅是鸟类，但不能飞行
public class Penguin : Bird
{
    public override void Fly()
    {
        // 企鹅不能飞行，抛出异常
        throw new NotSupportedException("企鹅不能飞行");
    }
}

public class BirdManager
{
    public void LetBirdFly(Bird bird)
    {
        // 如果传入Penguin对象，这里会抛出异常
        bird.Fly();
    }
}

应用里氏替换原则后的代码：

// 遵循里氏替换原则的示例

// 基类只包含所有鸟类共有的特性
public abstract class Bird
{
    public abstract void Move();
}

// 会飞的鸟
public class FlyingBird : Bird
{
    public override void Move()
    {
        Fly();
    }
    
    public virtual void Fly()
    {
        Console.WriteLine("鸟儿飞行");
    }
}

// 不会飞的鸟
public class NonFlyingBird : Bird
{
    public override void Move()
    {
        Walk();
    }
    
    public virtual void Walk()
    {
        Console.WriteLine("鸟儿行走");
    }
}

// 具体的鸟类
public class Sparrow : FlyingBird
{
}

public class Penguin : NonFlyingBird
{
}

public class BirdManager
{
    public void MakeBirdMove(Bird bird)
    {
        // 无论传入什么鸟类，都能正确执行
        bird.Move();
    }
}

3.3 优势与应用场景

优势：

  • 增强代码的健壮性
  • 提高代码的可复用性
  • 保持继承体系的完整性
  • 避免继承层次中的行为不一致

应用场景：

  • 设计类的继承关系时
  • 重写父类方法时
  • 使用多态特性时
  • 编写基类和派生类时

4. 依赖倒置原则 (DIP)

4.1 原则定义

依赖倒置原则包含两个方面：

  1. 高层模块不应该依赖于低层模块，两者都应该依赖于抽象
  2. 抽象不应该依赖于细节，细节应该依赖于抽象
依赖倒置原则
高层模块
低层模块
抽象接口
细节
抽象不依赖细节

4.2 示例说明

下面是一个违反依赖倒置原则的例子：

// 违反依赖倒置原则的示例
public class EmailNotifier
{
    public void SendEmail(string message)
    {
        Console.WriteLine($"通过邮件发送通知: {message}");
    }
}

// 高层模块直接依赖低层模块
public class NotificationService
{
    private EmailNotifier emailNotifier;
    
    public NotificationService()
    {
        // 直接依赖具体实现
        emailNotifier = new EmailNotifier();
    }
    
    public void Notify(string message)
    {
        // 直接调用具体实现
        emailNotifier.SendEmail(message);
    }
}

应用依赖倒置原则后的代码：

// 遵循依赖倒置原则的示例

// 定义抽象接口
public interface INotifier
{
    void Send(string message);
}

// 实现具体的通知类
public class EmailNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"通过邮件发送通知: {message}");
    }
}

public class SMSNotifier : INotifier
{
    public void Send(string message)
    {
        Console.WriteLine($"通过短信发送通知: {message}");
    }
}

// 高层模块依赖于抽象
public class NotificationService
{
    private readonly INotifier notifier;
    
    // 通过依赖注入接收抽象接口
    public NotificationService(INotifier notifier)
    {
        this.notifier = notifier;
    }
    
    public void Notify(string message)
    {
        // 调用抽象接口
        notifier.Send(message);
    }
}

// 使用示例
public class Program
{
    public static void Main()
    {
        // 创建具体实现
        INotifier emailNotifier = new EmailNotifier();
        INotifier smsNotifier = new SMSNotifier();
        
        // 创建服务实例并注入依赖
        NotificationService emailService = new NotificationService(emailNotifier);
        NotificationService smsService = new NotificationService(smsNotifier);
        
        // 发送通知
        emailService.Notify("重要通知");
        smsService.Notify("紧急通知");
    }
}

4.3 优势与应用场景

优势：

  • 降低模块间的耦合度
  • 提高系统的可维护性和灵活性
  • 便于进行单元测试
  • 促进并行开发

应用场景：

  • 设计分层架构时
  • 使用依赖注入框架时
  • 进行单元测试时
  • 开发可插拔的组件或模块时

5. 接口隔离原则 (ISP)

5.1 原则定义

接口隔离原则是指客户端不应该被迫依赖于它不使用的方法。这个原则建议将庞大的接口拆分成更小更具体的接口，客户端只需要知道与之相关的方法。
接口隔离原则
大接口
拆分为
小而专一的接口
客户端只依赖所需接口

5.2 示例说明

下面是一个违反接口隔离原则的例子：

// 违反接口隔离原则的示例
public interface IWorker
{
    void Work();
    void Eat();
    void Sleep();
}

// 人类工人实现所有方法
public class HumanWorker : IWorker
{
    public void Work()
    {
        Console.WriteLine("人类工人工作");
    }
    
    public void Eat()
    {
        Console.WriteLine("人类工人吃饭");
    }
    
    public void Sleep()
    {
        Console.WriteLine("人类工人睡觉");
    }
}

// 机器人工人无法吃饭和睡觉
public class RobotWorker : IWorker
{
    public void Work()
    {
        Console.WriteLine("机器人工人工作");
    }
    
    public void Eat()
    {
        // 机器人不需要吃饭，但被迫实现此方法
        throw new NotSupportedException("机器人不需要吃饭");
    }
    
    public void Sleep()
    {
        // 机器人不需要睡觉，但被迫实现此方法
        throw new NotSupportedException("机器人不需要睡觉");
    }
}

应用接口隔离原则后的代码：

// 遵循接口隔离原则的示例

// 将大接口拆分为小接口
public interface IWorkable
{
    void Work();
}

public interface IEatable
{
    void Eat();
}

public interface ISleepable
{
    void Sleep();
}

// 人类工人需要实现所有接口
public class HumanWorker : IWorkable, IEatable, ISleepable
{
    public void Work()
    {
        Console.WriteLine("人类工人工作");
    }
    
    public void Eat()
    {
        Console.WriteLine("人类工人吃饭");
    }
    
    public void Sleep()
    {
        Console.WriteLine("人类工人睡觉");
    }
}

// 机器人工人只需要实现工作接口
public class RobotWorker : IWorkable
{
    public void Work()
    {
        Console.WriteLine("机器人工人工作");
    }
}

// 工作管理器只关心工作能力
public class WorkManager
{
    public void ManageWork(IWorkable worker)
    {
        worker.Work();
    }
}

// 生活管理器关心吃饭和睡觉
public class LifeManager
{
    public void ManageEating(IEatable eater)
    {
        eater.Eat();
    }
    
    public void ManageSleeping(ISleepable sleeper)
    {
        sleeper.Sleep();
    }
}

5.3 优势与应用场景

优势：

  • 避免类依赖不必要的接口方法
  • 提高接口的内聚性
  • 降低系统耦合度
  • 提高系统的灵活性和可维护性

应用场景：

  • 设计接口层次结构时
  • 当类被迫实现不需要的方法时
  • 重构具有多种功能的大型接口时
  • 设计SDK或API时

6. 合成复用原则 (CRP)

6.1 原则定义

合成复用原则是指优先使用对象组合/聚合，而不是继承关系达到复用的目的。组合/聚合可以在运行时动态地改变，而继承是静态的。
合成复用原则
优先使用
组合/聚合
而不是
继承

6.2 示例说明

下面是一个不恰当使用继承的例子：

// 不恰当使用继承的示例
public class Database
{
    public void Connect()
    {
        Console.WriteLine("连接到数据库");
    }
    
    public void Disconnect()
    {
        Console.WriteLine("断开数据库连接");
    }
    
    public void ExecuteQuery(string query)
    {
        Console.WriteLine($"执行查询: {query}");
    }
}

// 通过继承复用Database的功能
public class UserRepository : Database
{
    public void AddUser(string username)
    {
        Connect();
        ExecuteQuery($"INSERT INTO users VALUES ('{username}')");
        Disconnect();
    }
    
    public void DeleteUser(string username)
    {
        Connect();
        ExecuteQuery($"DELETE FROM users WHERE username = '{username}'");
        Disconnect();
    }
}

应用合成复用原则后的代码：

// 遵循合成复用原则的示例
public class Database
{
    public void Connect()
    {
        Console.WriteLine("连接到数据库");
    }
    
    public void Disconnect()
    {
        Console.WriteLine("断开数据库连接");
    }
    
    public void ExecuteQuery(string query)
    {
        Console.WriteLine($"执行查询: {query}");
    }
}

// 通过组合关系复用Database的功能
public class UserRepository
{
    // 组合方式引用Database
    private readonly Database database;
    
    public UserRepository(Database database)
    {
        this.database = database;
    }
    
    public void AddUser(string username)
    {
        database.Connect();
        database.ExecuteQuery($"INSERT INTO users VALUES ('{username}')");
        database.Disconnect();
    }
    
    public void DeleteUser(string username)
    {
        database.Connect();
        database.ExecuteQuery($"DELETE FROM users WHERE username = '{username}'");
        database.Disconnect();
    }
}

// 可以轻松切换到不同的数据库实现
public class MySqlDatabase : Database
{
    // MySQL特定实现
}

public class SqlServerDatabase : Database
{
    // SQL Server特定实现
}

6.3 优势与应用场景

优势：

  • 降低系统耦合度
  • 提高系统的灵活性
  • 避免类的爆炸性增长
  • 更好地遵循单一职责原则

应用场景：

  • 当需要复用功能但不需要继承接口时
  • 当需要在运行时动态改变行为时
  • 当继承会导致类爆炸时
  • 设计可插拔组件时

7. 迪米特法则 (LoD)

7.1 原则定义

迪米特法则（最少知识原则）是指一个对象应该对其他对象有最少的了解。一个类应该只与其直接相关的类交流，而不关心如何处理其他类。
迪米特法则
一个对象
应该对其他对象
有最少的了解

7.2 示例说明

下面是一个违反迪米特法则的例子：

// 违反迪米特法则的示例
public class Customer
{
    public string Name { get; set; }
}

public class Wallet
{
    public decimal Money { get; set; }
    
    public Wallet(decimal money)
    {
        Money = money;
    }
}

public class Customer2
{
    public string Name { get; set; }
    public Wallet Wallet { get; set; }
    
    public Customer2(string name, decimal money)
    {
        Name = name;
        Wallet = new Wallet(money);
    }
}

public class ShoppingCart
{
    public void Checkout(Customer2 customer, decimal amount)
    {
        // 直接访问客户的钱包，违反了迪米特法则
        if (customer.Wallet.Money >= amount)
        {
            customer.Wallet.Money -= amount;
            Console.WriteLine($"{customer.Name} 支付了 {amount} 元");
        }
        else
        {
            Console.WriteLine("余额不足");
        }
    }
}

应用迪米特法则后的代码：

// 遵循迪米特法则的示例
public class Customer
{
    private Wallet wallet;
    public string Name { get; }
    
    public Customer(string name, decimal money)
    {
        Name = name;
        wallet = new Wallet(money);
    }
    
    // 提供方法处理支付，不暴露钱包对象
    public bool Pay(decimal amount)
    {
        return wallet.TryTakeMoney(amount);
    }
}

public class Wallet
{
    private decimal money;
    
    public Wallet(decimal money)
    {
        this.money = money;
    }
    
    public bool TryTakeMoney(decimal amount)
    {
        if (money >= amount)
        {
            money -= amount;
            return true;
        }
        return false;
    }
}

public class ShoppingCart
{
    public void Checkout(Customer customer, decimal amount)
    {
        // 不直接访问钱包，而是请求客户进行支付
        if (customer.Pay(amount))
        {
            Console.WriteLine($"{customer.Name} 支付了 {amount} 元");
        }
        else
        {
            Console.WriteLine("余额不足");
        }
    }
}

7.3 优势与应用场景

优势：

  • 降低类之间的耦合度
  • 提高模块的相对独立性
  • 提高系统的可维护性
  • 降低风险，防止不必要的内部暴露

应用场景：

  • 设计对象交互方式时
  • 重构高耦合代码时
  • 设计API和公共接口时
  • 处理复杂对象关系时

总结

设计模式的七大原则是软件开发中提高代码质量的重要指导方针。这些原则不是相互独立的，而是相互关联、相互补充的。理解并应用这些原则，可以帮助我们设计出更加灵活、可维护、可扩展的代码。

总结来说：

  • 单一职责原则要求一个类只负责一项职责
  • 开闭原则强调对扩展开放，对修改关闭
  • 里氏替换原则确保子类能够替换父类而不影响程序正确性
  • 依赖倒置原则建议依赖抽象而非具体实现
  • 接口隔离原则建议使用多个专门接口而非单一大接口
  • 合成复用原则推荐使用组合而非继承
  • 迪米特法则要求对象之间的交互应该限制在最小范围内

这些原则不应该被视为绝对的规则，而是设计中的指导方针。在实际应用中，我们需要权衡各种因素，包括性能、复杂性、可维护性等，选择最适合当前项目需求的设计方案。

相关学习资源

  1. 书籍：

    • 《设计模式：可复用面向对象软件的基础》- 四人帮(GoF)
    • 《C#设计模式》- Gary McLean Hall
    • 《敏捷软件开发：原则、模式与实践》- Robert C. Martin
    • 《代码整洁之道》- Robert C. Martin

  2. 网站：

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰茶_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值