C# 设计模式的七大原则详解

文章目录

前言
1. 单一职责原则 (SRP)
2. 开放封闭原则 (OCP)
3. 里氏替换原则 (LSP)
4. 依赖倒置原则 (DIP)
5. 接口隔离原则 (ISP)
6. 合成/聚合复用原则 (CARP)
7. 迪米特法则 (LoD)

前言

在 C# 编程中，设计模式的七大原则是保证代码质量和可维护性的基石。这些原则不仅仅是理论上的指导，更是在实际项目开发中的重要实践。本文将详细解释每个原则，并附上相应的 C# 示例代码，帮助读者更好地理解和应用这些原则。

1. 单一职责原则 (SRP)

单一职责原则要求一个类应该只有一个引起变化的原因，即一个类只负责一项功能。这有助于保持类的简洁性和可维护性，降低代码的复杂度。

示例代码：

using System;// 不好的设计，一个类负责了两个不同的功能
class BadDesign
{public void ProcessData(){// 处理数据的逻辑}public void GenerateReport(){// 生成报告的逻辑}
}// 好的设计，将功能分开到不同的类中
class DataProcessor
{public void ProcessData(){// 处理数据的逻辑}
}class ReportGenerator
{public void GenerateReport(){// 生成报告的逻辑}
}

2. 开放封闭原则 (OCP)

开放封闭原则要求软件实体应该对扩展开放，对修改关闭。这意味着通过扩展已有的代码来实现新的功能，而不是修改已有的代码。

示例代码：

using System;// 不好的设计，需要修改原有类来添加新功能
class BadDesign
{public void ProcessData(){// 处理数据的逻辑}
}// 好的设计，通过扩展来添加新功能
interface IDataProcessor
{void ProcessData();
}class DataProcessor : IDataProcessor
{public void ProcessData(){// 处理数据的逻辑}
}class NewFeatureProcessor : IDataProcessor
{public void ProcessData(){// 新功能的处理逻辑}
}

3. 里氏替换原则 (LSP)

里氏替换原则要求子类型必须能够替换掉它们的父类型，确保子类可以完全替代父类，并且不会影响系统的正确性。

示例代码：

using System;// 不好的设计，子类修改了父类的行为
class BadDesign
{public virtual void ProcessData(){// 处理数据的逻辑}
}class Child : BadDesign
{public override void ProcessData(){// 修改了父类的行为}
}// 好的设计，子类不修改父类的行为
class GoodDesign
{public void ProcessData(){// 处理数据的逻辑}
}class Child : GoodDesign
{// 不需要重写父类的方法
}

4. 依赖倒置原则 (DIP)

依赖倒置原则要求高层模块不应该依赖于低层模块，二者都应该依赖于抽象。这有助于降低模块之间的耦合度。

示例代码：

using System;// 不好的设计，高层模块直接依赖于低层模块
class BadDesign
{private LowLevelDependency dependency = new LowLevelDependency();
}class LowLevelDependency
{// 低层模块的功能实现
}// 好的设计，高层模块依赖于抽象
interface IDependency
{void DoSomething();
}class GoodDesign
{private IDependency dependency;public GoodDesign(IDependency dependency){this.dependency = dependency;}
}class LowLevelDependency : IDependency
{public void DoSomething(){// 功能实现}
}

5. 接口隔离原则 (ISP)

接口隔离原则要求客户端不应该被迫依赖于它们不使用的接口，避免接口过于庞大、臃肿。

示例代码：

using System;// 不好的设计，一个接口包含了多个不相关的方法
interface IBadInterface
{void Method1();void Method2();void Method3();
}// 好的设计，根据客户端的需求定义专门的接口
interface IGoodInterface1
{void Method1();
}interface IGoodInterface2
{void Method2();
}

6. 合成/聚合复用原则 (CARP)

合成/聚合复用原则要求尽量使用合成/聚合，而不是继承来实现代码复用，以避免继承带来的紧耦合和继承链的脆弱性。

示例代码：

using System;// 不好的设计，使用继承来复用代码
class BadDesign
{// 共享的逻辑
}class Child : BadDesign
{// 子类的特定逻辑
}// 好的设计，使用组合来复用代码
class GoodDesign
{private SharedLogic sharedLogic;public GoodDesign(SharedLogic sharedLogic){this.sharedLogic = sharedLogic;}
}

7. 迪米特法则 (LoD)

迪米特法则要求一个对象应该对其他对象有尽可能少的了解，避免类之间的直接通信，降低耦合度。

示例代码：

using System;// 不好的设计，类直接依赖于其他类
class BadDesign
{private Dependency dependency = new Dependency();public void DoSomething(){// 使用 dependency 的功能}
}// 好的设计，通过中介者来减少直接依赖
class GoodDesign
{private Mediator mediator;public GoodDesign(Mediator mediator){this.mediator = mediator;}public void DoSomething(){mediator.DoSomething();}
}class Mediator
{private Dependency dependency = new Dependency();public void DoSomething(){// 使用 dependency 的功能}
}