结构型设计模式1

文章目录

适配器模式👍

1、定义与核心思想

（1）定义

• 适配器模式（Adapter Pattern） 是一种结构型设计模式，用于解决接口不兼容的问题。
• 核心目标是通过一个中间层（适配器），将现有接口转换为客户端期望的接口，使原本无法协同工作的类能够协同工作。
• 例如，电源转换器将不同国家的电压标准统一。

（2）模式类型

• 类适配器：通过继承适配者类并实现目标接口（C#因不支持多重继承，实际应用中较少使用）。
• 对象适配器：通过组合方式持有适配者实例（推荐方式，灵活且符合合成复用原则）。

2、C#代码实现

（1）对象适配器

• 通过组合适配者实例，适配器将SpecificRequest()转换为Request()，客户端无需直接依赖Adaptee

// 目标接口（客户端期望的接口）
public interface ITarget
{void Request();
}// 适配者类（需被适配的类）
public class Adaptee
{public void SpecificRequest(){Console.WriteLine("Adaptee的特定请求方法");}
}// 适配器类
public class Adapter : ITarget
{private readonly Adaptee _adaptee;public Adapter(Adaptee adaptee){_adaptee = adaptee;}public void Request(){// 调用适配者的方法_adaptee.SpecificRequest();}
}// 客户端调用
class Program
{static void Main(string[] args){Adaptee adaptee = new Adaptee();ITarget target = new Adapter(adaptee);target.Request(); // 输出：Adaptee的特定请求方法}
}

（2）类适配器

• C#不支持多重继承，但可通过实现接口+继承基类模拟
• 局限性：仅适用于适配者为非密封类的情况，且可能导致耦合度较高

public interface ITarget
{void Request();
}public class Adaptee
{public void SpecificRequest(){Console.WriteLine("Adaptee的方法");}
}// 类适配器（继承Adaptee并实现ITarget）
public class Adapter : Adaptee, ITarget
{public void Request(){SpecificRequest();}
}

3、应用场景

（1）集成第三方库或遗留代码

• 当引入第三方组件接口与现有系统不兼容时，适配器可隔离变化，避免直接修改外部代码。
• 示例：旧版日志系统适配到新接口：

// 旧日志类（Adaptee）
public class LegacyLogger
{public void Log(string message, int level){Console.WriteLine($"[Legacy] Level {level}: {message}");}
}// 新日志接口（Target）
public interface ILogger
{void Info(string message);void Error(string message);
}// 适配器
public class LoggerAdapter : ILogger
{private LegacyLogger _legacyLogger = new LegacyLogger();public void Info(string message){_legacyLogger.Log(message, 1);}public void Error(string message){_legacyLogger.Log(message, 3);}
}

（2）统一多数据源接口

• 例如将不同数据库（SQL Server、MySQL）的访问接口统一为IDatabase。

public interface IDatabase
{void Execute(string query);
}// MySQL适配器
public class MySqlAdapter : IDatabase
{private MySqlClient _mysql = new MySqlClient();public void Execute(string query){_mysql.RunQuery(query);}
}// SQL Server适配器
public class SqlServerAdapter : IDatabase
{private SqlClient _sql = new SqlClient();public void Execute(string query){_sql.ExecuteCommand(query);}
}

（3）跨平台兼容

• 在跨平台应用中，适配不同操作系统的文件系统接口。

public interface IFileSystem
{void SaveFile(string path, byte[] data);
}// Linux系统适配器
public class LinuxFileAdapter : IFileSystem
{public void SaveFile(string path, byte[] data){File.WriteAllBytes($"/mnt/{path}", data);}
}

4、扩展与优化

（1）双向适配器

• 允许适配者和目标接口相互调用，适用于需要双向转换的场景：

public class BiDirectionalAdapter : ITarget, IAdaptee
{private ITarget _target;private IAdaptee _adaptee;public BiDirectionalAdapter(ITarget target, IAdaptee adaptee){_target = target;_adaptee = adaptee;}public void Request(){_adaptee.SpecificRequest();}public void SpecificRequest(){_target.Request();}
}

（2）线程安全适配器

• 通过锁机制确保多线程环境下的安全调用：

public class ThreadSafeAdapter : ITarget
{private readonly Adaptee _adaptee;private readonly object _lock = new object();public ThreadSafeAdapter(Adaptee adaptee){_adaptee = adaptee;}public void Request(){lock (_lock){_adaptee.SpecificRequest();}}
}

（3）延迟加载适配器

• 推迟适配者实例化，优化资源使用：

public class LazyAdapter : ITarget
{private Lazy<Adaptee> _lazyAdaptee;public LazyAdapter(){_lazyAdaptee = new Lazy<Adaptee>(() => new Adaptee());}public void Request(){_lazyAdaptee.Value.SpecificRequest();}
}

（4）与其他模式的结合

• 与工厂模式结合：通过工厂创建适配器，隐藏实例化细节。
• 与装饰器模式结合：在适配过程中添加额外功能（如日志记录）。
• 与策略模式结合：动态选择不同的适配策略。

5、优缺点分析

（1）优点

• 解耦性：隔离客户端与适配者的直接依赖。
• 复用性：重用现有类，无需修改其代码。
• 扩展性：支持多适配者组合，灵活应对变化。

（2）缺点

• 复杂性：过度使用会导致系统结构复杂化。
• 性能损耗：多层间接调用可能影响性能（可通过缓存优化）。

6、实际案例

（1）支付网关适配

• 统一支付宝、微信支付等不同接口：

public interface IPaymentGateway
{void Pay(decimal amount);
}public class WeChatPaymentAdapter : IPaymentGateway
{private WeChatPay _wechatPay = new WeChatPay();public void Pay(decimal amount){_wechatPay.Transfer(amount);}
}

（2）数据格式转换

• 将XML数据转换为JSON格式输出：

public class XmlToJsonAdapter : IDataFormatter
{private XmlParser _xmlParser = new XmlParser();public string FormatData(string input){var xmlData = _xmlParser.Parse(input);return JsonConvert.SerializeObject(xmlData);}
}

桥接模式👍

1、定义与核心思想

（1）定义

• 桥接模式（Bridge Pattern）是一种结构型设计模式，将抽象部分与实现部分分离，使其可以独立变化。
• 核心通过组合关系替代继承，解决多维度的类爆炸问题，提高系统扩展性。

（2）核心思想

• 解耦：抽象层（如形状）与实现层（如渲染方式）通过接口或抽象类组合，而非继承。
• 独立演化：双方变化互不影响，例如新增渲染技术无需修改形状类。

（3）结构及角色

• 抽象类（Abstraction）：定义高层接口，持有实现层引用。
• 扩展抽象类（Refined Abstraction）：实现抽象类的业务逻辑。
• 实现接口（Implementor）：定义底层操作的接口。
• 具体实现类（Concrete Implementor）：实现接口的具体功能。
• UML类图示例：

+----------------+       +-------------------+
|   IShape       |<>---->|  IRenderer        |
+----------------+       +-------------------+
| +Draw()        |       | +Render(string)   |
+----------------+       +-------------------+△                          △|                          |
+----------------+       +-------------------+
| Circle         |       | VectorRenderer    |
+----------------+       +-------------------+
| -radius:double |       | +Render()         |
+----------------+       +-------------------+

（4）应用场景

• 多维度变化：如GUI控件（控件类型×主题风格）。
• 跨平台开发：业务逻辑与平台实现解耦（如Android/iOS的绘图库）。
• 动态切换实现：运行时切换算法或组件（如日志记录方式）。

2、C#代码实现

• 场景：图形渲染系统，支持不同形状（圆形、方形）和渲染方式（矢量、光栅），避免类爆炸（如CircleVector、CircleRaster等）。

（1）实现接口（IRenderer）

// 渲染接口
public interface IRenderer
{void Render(string shapeName);
}

（2）具体实现类（VectorRenderer, RasterRenderer）

// 矢量渲染
public class VectorRenderer : IRenderer
{public void Render(string shapeName){Console.WriteLine($"矢量渲染：{shapeName}");}
}// 光栅渲染
public class RasterRenderer : IRenderer
{public void Render(string shapeName){Console.WriteLine($"光栅渲染：{shapeName}");}
}

（3）抽象类（Shape）

public abstract class Shape
{protected IRenderer Renderer;public string Name { get; set; }protected Shape(IRenderer renderer){Renderer = renderer;}public abstract void Draw();
}

（4）扩展抽象类（Circle, Square）

// 圆形
public class Circle : Shape
{public double Radius { get; set; }public Circle(IRenderer renderer, double radius) : base(renderer){Radius = radius;Name = "圆形";}public override void Draw(){Renderer.Render($"半径={Radius}的{Name}");}
}// 方形
public class Square : Shape
{public double SideLength { get; set; }public Square(IRenderer renderer, double side) : base(renderer){SideLength = side;Name = "方形";}public override void Draw(){Renderer.Render($"边长={SideLength}的{Name}");}
}

（5）客户端调用

var vectorRenderer = new VectorRenderer();
var rasterRenderer = new RasterRenderer();var circle = new Circle(vectorRenderer, 5.0);
circle.Draw(); // 输出：矢量渲染：半径=5的圆形var square = new Square(rasterRenderer, 10.0);
square.Draw(); // 输出：光栅渲染：边长=10的方形

（6）实际应用

• 依赖注入（DI）：通过IoC容器自动绑定实现类（如ASP.NET Core中注入IRenderer）。
• 工厂模式结合：用工厂类动态创建抽象与实现的组合。
• 模板方法扩展：在抽象类中定义默认行为，子类覆盖细节。

3、优缺点分析

（1）优势

• 低耦合：抽象与实现独立扩展。
• 高复用性：同一实现可被多个抽象复用。
• 灵活性：动态组合多维属性。

（2）局限

• 设计复杂度：需提前识别变化的维度。
• 接口冗余：若维度变化少，可能过度设计。

（3）对比其他模式

模式	核心目标	适用场景
桥接模式	解耦多维变化	多独立维度的组合（如形状×渲染）
适配器模式	解决接口不兼容	旧系统适配新接口
策略模式	动态切换算法	单一维度的行为替换（如排序算法）

装饰器模式👍

1、定义与核心思想

（1）定义

• 装饰器模式是一种结构型设计模式，其核心在于动态地为对象添加职责，而无需修改原有类或继承结构。
• 该模式通过将对象包装在装饰器类的实例中，以组合替代继承的方式扩展功能，遵循开闭原则（对扩展开放，对修改关闭）。

（2）应用场景

• 动态功能扩展：如日志记录、权限验证、缓存等
• 避免子类爆炸：当需要多种功能组合时（如不同配置的咖啡加料）
• 运行时行为增强：如UI组件的边框/滚动条动态添加

（3）结构及角色

• 类图构成

           <<interface>>  IComponent↑+------+------+|             |
ConcreteComponent  Decorator（抽象）↑ConcreteDecoratorA/B

• 关键角色：
  • IComponent：定义基础操作的接口（如Operation()）
  • ConcreteComponent：实现基础功能的具体类（如基础文本显示）
  • Decorator：持有一个IComponent引用，实现相同接口
  • ConcreteDecorator：添加具体扩展逻辑（如边框装饰）
• 代码实现要点
  • 接口一致性：装饰器必须与组件实现相同接口
  • 透明性：客户端无需区分原始对象与装饰后的对象
  • 递归组合：装饰器可嵌套多层（如DecoratorA(DecoratorB(BaseComponent))）
• 生命周期管理：
  • 使用IDisposable确保嵌套对象正确释放
  • 避免循环引用（可通过弱引用WeakReference处理）

2、C#代码实现

（1）案例1：足球比赛阵型调整

• 需求：比赛上下半场动态切换防守/进攻策略而不修改基础类。

// 组件接口
public abstract class OurStrategy {public abstract void Play(string msg);
}// 基础策略（防守阵型）
public class DefenseStrategy : OurStrategy {public override void Play(string msg) {Console.WriteLine("上半场默认4-4-2防守阵型");}
}// 装饰器基类
public abstract class StrategyDecorator : OurStrategy {protected OurStrategy _strategy;public StrategyDecorator(OurStrategy strategy) {_strategy = strategy;}public override void Play(string msg) {_strategy?.Play(msg);}
}// 具体装饰器（进攻策略）
public class AttackDecorator : StrategyDecorator {public AttackDecorator(OurStrategy strategy) : base(strategy) {}public override void Play(string msg) {base.Play(msg);Console.WriteLine("附加进攻策略：三前锋压制");}
}// 使用示例
var strategy = new AttackDecorator(new DefenseStrategy());
strategy.Play("下半场调整");

• 输出结果：

上半场默认4-4-2防守阵型
附加进攻策略：三前锋压制

（2）案例2：电商产品套餐组合

• 需求：灵活组合基础商品与附加服务（如包装、赠品）。

// 抽象组件
public abstract class Product {public abstract string GetDescription();public abstract double GetPrice();
}// 具体组件（基础商品）
public class BasicProduct : Product {private string _name;private double _price;public BasicProduct(string name, double price) {_name = name;_price = price;}public override string GetDescription() => _name;public override double GetPrice() => _price;
}// 装饰器基类
public abstract class ProductDecorator : Product {protected Product _product;public ProductDecorator(Product product) {_product = product;}
}// 具体装饰器（礼盒包装）
public class GiftWrapDecorator : ProductDecorator {public GiftWrapDecorator(Product product) : base(product) {}public override string GetDescription() => $"{_product.GetDescription()} + 豪华礼盒";public override double GetPrice() => _product.GetPrice() + 25.0;
}// 客户端调用
Product package = new GiftWrapDecorator(new BasicProduct("景德镇瓷器", 299.0));
Console.WriteLine($"{package.GetDescription()} - 总价:{package.GetPrice()}");

• 输出：景德镇瓷器 + 豪华礼盒 - 总价:324

（3）案例3：日志记录装饰器

• 此实现为数据服务添加日志追踪能力

public class LoggingDecorator : IDataService {private IDataService _service;private ILogger _logger;public LoggingDecorator(IDataService service, ILogger logger) {_service = service;_logger = logger;}public object GetData(string query) {_logger.Info($"查询开始: {query}");var result = _service.GetData(query);_logger.Info($"查询完成: {result.Length}条记录");return result;}
}

（4）案例4：缓存装饰器

• 此装饰器通过内存缓存减少API调用次数

public class CacheDecorator : IApiClient {private IApiClient _client;private MemoryCache _cache = new MemoryCache();public CacheDecorator(IApiClient client) {_client = client;}public string Get(string url) {if(_cache.Contains(url)) return _cache.Get(url) as string;var data = _client.Get(url);_cache.Add(url, data, DateTime.Now.AddMinutes(10));return data;}
}

（5）案例5：UI组件增强

• 输出：绘制基础文本框 → 添加边框 → 添加滚动条

// 基础文本框
public class TextBox : IControl {public void Draw() => Console.WriteLine("绘制基础文本框");
}// 滚动条装饰器
public class ScrollDecorator : ControlDecorator {public ScrollDecorator(IControl control) : base(control) {}public override void Draw() {base.Draw();Console.WriteLine("添加垂直滚动条");}
}// 使用
var textBox = new ScrollDecorator(new BorderDecorator(new TextBox()));
textBox.Draw();

（6）案例6：权限控制管道

• 在命令执行前插入权限检查

public class AuthorizationDecorator : ICommandHandler<TCommand> {private ICommandHandler<TCommand> _inner;private IUserContext _userContext;public AuthorizationDecorator(ICommandHandler<TCommand> inner, IUserContext user) {_inner = inner;_userContext = user;}public void Handle(TCommand command) {if(!_userContext.HasPermission(command.RequiredPermission))throw new SecurityException();_inner.Handle(command);}
}

（7）注意事项

• 装饰顺序敏感：某些装饰器的顺序会影响最终结果（如先加密后压缩 vs 先压缩后加密）
• 线程安全：多层装饰器共享状态时需同步控制
• DI容器集成：通过依赖注入框架（如ASP.NET Core）自动装配装饰链

services.AddScoped<IDataService, BasicDataService>();
services.Decorate<IDataService, CacheDecorator>();
services.Decorate<IDataService, LoggingDecorator>();

• AOP替代方案：对于横切关注点（如日志），可结合AOP框架（如PostSharp）实现

（8）最佳实践

• 使用准则：
  • 当需要动态、透明地添加职责时优先选择
  • 避免超过3层装饰（可通过组合模式优化）
  • 对装饰器进行单元测试（包括单独测试和组合测试）
• 性能优化策略：
  • 缓存频繁使用的装饰链
  • 采用轻量级装饰器（如避免重复初始化）
  • 异步执行非关键装饰逻辑（如日志写入）
• 架构影响：
  • 促进松耦合架构
  • 支持微服务中的装饰链模式（如API网关的过滤链）
  • 与领域驱动设计（DDD）中的装饰器应用结合

3、优缺点分析

（1）优势

• 灵活扩展：比继承更灵活，支持运行时动态组合
• 单一职责：每个装饰器只关注单一功能
• 避免类爆炸：通过组合替代多层次继承

（2）局限性

• 对象标识问题：装饰后的对象与原对象类型不同（is判断可能失效）
• 调试复杂度：多层装饰导致调用链难以追踪
• 性能损耗：每层装饰带来额外调用开销（可通过缓存优化）

（3）对比其他模式

模式	核心差异	适用场景
策略模式	改变对象算法	多种算法可替换
代理模式	控制访问/延迟初始化	访问控制、虚拟代理
组合模式	处理树形结构	UI组件嵌套
适配器模式	接口转换	新旧系统兼容

外观模式

1、定义与核心思想

（1）定义

• 外观模式（Facade Pattern）是一种结构型设计模式，其核心思想是为复杂的子系统提供一个统一的高层接口，简化客户端调用。
• 通过封装子系统的内部细节，外观模式降低了客户端与子系统之间的耦合度，提升了系统的可维护性和扩展性。

（2）核心目标

• 简化接口：隐藏子系统的复杂性。
• 解耦：减少客户端对子系统的直接依赖。
• 统一入口：提供一致的调用方式。

（3）结构与角色

• Facade（外观类）：
  • 封装子系统的接口，负责将客户端请求转发到对应的子系统。
  • 知道如何组合子系统的方法以满足客户端需求。
• Subsystem Classes（子系统类集合）：
  • 实现子系统的具体功能，但不直接与客户端交互。

（4）适用场景

• 复杂子系统调用：例如微服务架构中的服务聚合。
• 第三方SDK封装：提供简化的API接口。
• 遗留系统改造：通过外观类包装旧代码，逐步重构。
• 分层架构：服务层封装数据访问层和业务逻辑层。

2、C#代码实现

（1）基础实现

• 代码解析
  • 子系统类独立实现功能。
  • 外观类通过构造函数依赖注入子系统实例。
  • 客户端仅需调用外观类的方法即可完成复杂操作

// 子系统接口
public interface ISubsystem
{void Method1();void Method2();
}// 子系统实现类
public class Subsystem1 : ISubsystem
{public void Method1() => Console.WriteLine("Subsystem1 方法1");public void Method2() => Console.WriteLine("Subsystem1 方法2");
}public class Subsystem2 : ISubsystem
{public void Method1() => Console.WriteLine("Subsystem2 方法1");public void Method2() => Console.WriteLine("Subsystem2 方法2");
}// 外观类
public class Facade
{private readonly ISubsystem _subsystem1;private readonly ISubsystem _subsystem2;public Facade(ISubsystem subsystem1, ISubsystem subsystem2){_subsystem1 = subsystem1;_subsystem2 = subsystem2;}// 统一接口方法public void ExecuteComplexOperation(){_subsystem1.Method1();_subsystem2.Method2();}
}// 客户端调用
class Client
{static void Main(){var subsystem1 = new Subsystem1();var subsystem2 = new Subsystem2();var facade = new Facade(subsystem1, subsystem2);facade.ExecuteComplexOperation();  // 输出：Subsystem1 方法1 → Subsystem2 方法2}
}

（2）微服务下单系统示例

• 适用场景：微服务架构下，订单流程涉及多个子系统的协作

// 物流子系统
public interface ILogisticsSystem
{bool CheckLogistics(int productId, int cityId);void NewLogistics(int productId, int cityId);
}public class LogisticsSystem : ILogisticsSystem
{public bool CheckLogistics(int productId, int cityId) => true;public void NewLogistics(int productId, int cityId) => Console.WriteLine($"商品[{productId}]从城市[{cityId}]发货");
}// 库存子系统
public interface IStorageSystem { bool CheckStorage(int productId); }
public class StorageSystem : IStorageSystem 
{public bool CheckStorage(int productId) => true;
}// 订单子系统
public interface IOrderSystem { void CreateOrder(int productId); }
public class OrderSystem : IOrderSystem 
{public void CreateOrder(int productId) => Console.WriteLine($"订单已生成，商品ID：{productId}");
}// 外观类：下单服务
public class OrderFacade
{private readonly ILogisticsSystem _logistics;private readonly IStorageSystem _storage;private readonly IOrderSystem _order;public OrderFacade(){_logistics = new LogisticsSystem();_storage = new StorageSystem();_order = new OrderSystem();}public void PlaceOrder(int productId, int cityId){if (_storage.CheckStorage(productId) && _logistics.CheckLogistics(productId, cityId)){_order.CreateOrder(productId);_logistics.NewLogistics(productId, cityId);}}
}// 客户端调用
var facade = new OrderFacade();
facade.PlaceOrder(1001, 101); 
// 输出：订单已生成 → 商品发货

（3）智能家居控制示例

• 应用场景：统一管理多个智能设备的开关操作

public interface IDevice
{void TurnOn();void TurnOff();
}// 子系统：热水器
public class WaterHeater : IDevice
{public void TurnOn() => Console.WriteLine("热水器已开启");public void TurnOff() => Console.WriteLine("热水器已关闭");
}// 子系统：灯光
public class Light : IDevice
{public void TurnOn() => Console.WriteLine("灯光已开启");public void TurnOff() => Console.WriteLine("灯光已关闭");
}// 外观类：智能家居控制器
public class SmartHomeFacade
{private readonly IDevice _heater;private readonly IDevice _light;public SmartHomeFacade(IDevice heater, IDevice light){_heater = heater;_light = light;}public void ActivateHomeMode(){_heater.TurnOn();_light.TurnOn();}public void DeactivateHomeMode(){_heater.TurnOff();_light.TurnOff();}
}

3、进阶用法

（1）依赖注入（DI）优化

• 通过依赖注入（如ASP.NET Core的IServiceCollection）动态管理子系统实例：

services.AddSingleton<ILogisticsSystem, LogisticsSystem>();
services.AddScoped<OrderFacade>();

（2）异步编程支持

• 针对耗时操作（如网络请求），可采用异步方法：

public async Task PlaceOrderAsync(int productId, int cityId)
{var stockTask = _storage.CheckStorageAsync(productId);var logisticsTask = _logistics.CheckLogisticsAsync(productId, cityId);await Task.WhenAll(stockTask, logisticsTask);// 后续操作...
}

（3）动态外观模式

• 通过反射动态加载子系统：

public class DynamicFacade
{private Dictionary<string, object> _subsystems = new();public void AddSubsystem(string key, object subsystem) => _subsystems[key] = subsystem;public void Execute(string methodName){foreach (var subsystem in _subsystems.Values){var method = subsystem.GetType().GetMethod(methodName);method?.Invoke(subsystem, null);}}
}

4、优缺点分析

（1）优点

• 简化调用：客户端只需与外观类交互，无需了解子系统细节。
• 降低耦合：子系统修改不影响客户端。
• 统一入口：集中管理复杂流程（如事务控制）。

（2）缺点

• 违反开闭原则：新增功能可能需要修改外观类。
• 性能损失：多层封装可能增加调用链。