所有创意设计模式 - MetaTrader 5 库

//+------------------------------------------------------------------+
//|                                             PatternOrganizer.mqh |
//|                                    2019-2020，迪米特里·佩切里察 |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
//| 23 种设计模式                                                |
//+------------------------------------------------------------------+
//   设计模式：可重用的面向对象软件的元素
//   gof > 埃里希·伽马、理查德·赫尔姆、拉尔夫·约翰逊、约翰·弗利赛德斯
//   发表于 1994 年
//+------------------------------------------------------------------+
//|分类                                                   |
//+------------------------------------------------------------------+
//   目的 > 创造 > 5
//      抽象工厂、构建器、工厂方法、原型、单例
//   目的 > 结构 > 7
//      适配器、桥接器、复合器、装饰器、门面、享元、代理
//   目的 > 行为 > 11
//      责任链、命令、解释器、迭代器、中介器
//      备忘录、观察者、状态、策略、模板方法、访问者
//   作用域 > 类 > 3 > 工厂方法、解释器、模板方法
//   范围 > 对象 > 20 > 所有其他
//+------------------------------------------------------------------+
//|关系                                                    |
//+------------------------------------------------------------------+
//
//                       +-------------->|备忘录|      |代理|
//                       |                   ^           |适配器|
//                  保存状态             |            |桥梁|
//                  迭代          避免
//                       |               滞后现象
//    |构建器|      |迭代器|<---+         |        |   链 | 链
//        ^              ^         |     |命令|    |责任|
//        |              |         |         |               |
//     创建     枚举    |      组成        定义
//    复合材料      儿童     |       使用         链条
//        |              |         |         |               |
//        +---------|复合|<---|--------+----------------+
//        |              |         |                         |
//     添加            |     定义------------+      定义
// 职责      |    遍历           |      语法
//   对象          |                         |         |
//        |              +--------添加------>|访客|     |
//        v              |      运营                   |
//   |装饰器|      分享       |                        |
//        ^          复合材料     +--------|解释器|---+
//        |              |                         |
//        |              v             分享     |
//  改变皮肤     |flyweight|<-----terminal----+
//    与胆量               ^         符号          |观察者|
//        |       分享    |                              |
//        |     策略---+---分享                    |
//        v          |           状态                  复杂
//   |策略|------+             |     |中介|<----依赖
//        ^                     |状态|                 管理
//        |
//     分享
//   算法的----------|模板方法|----经常使用---+
//      步骤                                              |
//                                                          |
//   |原型|<--+                                        |
//                 |                                        v
//         配置工厂          实现---->|工厂方法|
//            动态               使用
//                 |                      |
//         |抽象工厂|---+--------+
//                              |
//                           单身的
//   |singleton|<-----------实例------------|外观|
//
//+------------------------------------------------------------------+
//|代码重构                                                 |
//+------------------------------------------------------------------+
//   创建对象<显式>间接创建
//      抽象工厂、工厂方法、原型
//   依赖 > 特定操作 > 避免 > 硬编码请求
//      责任链、命令
//   依赖 > 硬件和软件 > 限制
//      抽象工厂、桥
//   依赖 > 对象表示/实现
//      对客户端隐藏 > 防止级联更改
//      抽象工厂、桥、备忘录、代理
//   算法依赖 > 隔离 > 可能改变的算法
//      构建器、迭代器、策略、模板方法、访问者
//   紧密耦合 > 解耦 < 抽象耦合和分层
//      抽象工厂、桥梁、责任链、
//      命令、外观、中介、观察者
//   扩展功能 < 子类化
//      组合/委托 > 组合行为
//      桥梁、责任链、复合、装饰器、
//      观察者、策略
//   无法方便地更改类 > 适配器、装饰器、访问者
//+------------------------------------------------------------------+
//|创作 > 抽象工厂                                   |
//+------------------------------------------------------------------+
//   接口 > 相关/依赖对象系列
//    不指定具体类
//   变量方面 > 产品对象系列
//
//            | AbstractFactory|<--------------------------------------------------------|客户端|
//            |----------------|                                              |
//            |CreateProductA()|                                              |
//            |CreateProductA()|                    |抽象产品A|<--------+
//                     ^                                   ^                 |
//                     |                                    |                 |
//         +-----------+----------+                   +-----+-----+           |
//         |                      |                   |           |           |
//|ConcreteFactory1|- +  |ConcreteFactory2|- + ->|ProductA2| |产品A1|<- +  |
//|----------------|  |  |----------------|  |                             |  |
//|创建产品A()|     |创建产品A()|                                   |
//|创建产品B()|  |  |创建产品B()|  |                             |  |
//                                                  |AbstractProductB|<----+--+
//                    |                      |              ^              |
//                                                          |
//                    |                      |        +-----+-----+        |
//                                                   |           |
//                    |                      + ->|产品B2| |产品B1|<- +
//                                                                         |
//                    +  - - - - - - - - - - - - - - - - - - - - - - - - - +
//
//+------------------------------------------------------------------+
//|创作 > 建造者                                            |
//+------------------------------------------------------------------+
//   对于复杂对象 > 将构造与表示分开
//  相同的构建过程可以创建不同的表示
//   变量方面 > 创建复合对象的方式
//
//                                  构建器
//  |           导演          |o--------->|  建设者 |
//  |-----------------------------------------|           |------------|
//  |Construct()                  |           |构建部分()|
//  |对于结构中的所有对象|                 ^
//  |  builder.BuildPart()        |                 |
//                                          |ConcreteBuilder|- - ->|产品|
//                                          |---------------|
//                                          |BuildPart()    |
//                                          |GetResult()    |
//
//+------------------------------------------------------------------+
//|创建 > 工厂方法                                      |
//+------------------------------------------------------------------+
//   用于创建对象的接口 > 将实例化推迟到子类
//   子类决定实例化哪个类
//   变量方面 > 实例化对象的子类
//
//                                 |         创建者        |
//                                 |------------------------|
//                                 |FactoryMethod()         |
//                                 |AnOperation()           |
//                                 | ...                    |
//                                 |产品=FactoryMethod()|
//        |产品|                | ...                    |
//            ^                                ^
//            |                                |
//    |混凝土产品|<- - - - -|      具体创建器      |
//                               |----------------------------|
//                               |FactoryMethod()             |
//                               |返回新的混凝土产品|
//
//+------------------------------------------------------------------+
//|创意 > 原型                                          |
//+------------------------------------------------------------------+
//   创建对象 > 通过复制原型
//   变量方面 > 实例化对象的类
//
//                         原型
//  |       客户       |------------>|原型|
//  |--------------------------------|             |---------|
//  |操作()         |             |克隆()  |
//  | p=原型.Clone()|                  ^
//                                         |
//                              +-----------+------------+
//                              |                        |
//                   |具体原型1 |   |具体原型2 |
//                   |--------------------|   |--------------------|
//                   |克隆()             |   |克隆()             |
//                   |返回自我副本|   |返回自我副本|
//
//+------------------------------------------------------------------+
//|创作 > 单例                                          |
//+------------------------------------------------------------------+
//   确保 > 具有全局访问点的类的一个实例
//   变量方面 > 类的唯一实例
//
//                       |       单例      |
//                       |------------------------------------|
//                       |静态实例()     |
//                       |返回唯一实例|
//                       |SingletonOperation()  |
//                       |GetSingletonData()    |
//                       |------------------------------------|
//                       |静态 uniqueInstance |
//                       |singletonData         |
//
//+------------------------------------------------------------------+
//|模式界面                                          |
//+------------------------------------------------------------------+
界面客户端示例//模式客户端  {
  细绳输出（空白）；//返回标头  空白跑步（空白）；//执行模式客户端  };//+------------------------------------------------------------------+
//|模式界面                                          |
//+------------------------------------------------------------------+
空白运行（客户端示例*客户端）//启动一个模式  {
  打印函数（“---\n%s”,client.Output());//打印模式标题   客户端.Run();//执行客户端协作  删除客户;//出口  }//+------------------------------------------------------------------+
//|包括 > 模式                                               |
//+------------------------------------------------------------------+
名称空间创意型
{＃包括“Creational\AbstractFactory.mqh”
＃包括“创建\Builder.mqh”
＃包括“创建\FactoryMethod.mqh”
＃包括“创建\原型.mqh”
＃包括“创建\Singleton.mqh”}//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                      模式.mq5 |
//|                                    2019-2020，迪米特里·佩切里察 |
//|                                                 792112@gmail.com |
//+------------------------------------------------------------------+
＃包括//+------------------------------------------------------------------+
//|运行                                                              |
//+------------------------------------------------------------------+
空白 启动时()//一一启动模式客户端并检查结果  {//---创作   跑步（新的创建::AbstractFactory::客户端);
   跑步（新的创造::建造者::客户);
   跑步（新的创建::工厂方法::客户端);
   跑步（新的创作::原型::客户端);
   跑步（新的创建::单例::客户端);
  }//+------------------------------------------------------------------+
//|输出 > 抽象工厂                                        |
//+------------------------------------------------------------------+
//   Creational::AbstractFactory::Client::Output
//   客户端请求创建工厂 1
//   客户端请求创建工厂客户端
//   客户端正在请求工厂客户端管理工厂 1
//   工厂 1: 3145728 已建成
//  工厂客户端创建并接收抽象工厂 3145728
//  工厂客户端请求接受/切换工厂
//   工厂客户端正在接受新工厂 3145728
//  工厂客户端保存了新工厂
//   工厂客户端正在请求其新工厂创建产品 a
//   工厂 1 正在创建并返回产品 a1
//   构造产品 a1
//   工厂客户端正在请求其新工厂创建产品 b
//   工厂 1 正在创建并返回产品 b1
//   构造产品 b1
//   客户端正在请求工厂客户端进行操作
//   工厂客户端正在运行抽象产品 b
//   产品 b1: 5242880 正在与产品 a: 4194304 交互
//   客户端请求创建新工厂 2 并要求工厂客户端切换工厂
//   工厂 2：6291456 已建成
//  工厂客户端正在将旧工厂 3145728 切换到新工厂 6291456
//  工厂客户端保存了新工厂
//   工厂客户端正在请求其新工厂创建产品 a
//   工厂 2 正在创建并返回产品 a2
//   构建产品 a2
//   工厂客户端正在请求其新工厂创建产品 b
//   工厂 2 正在创建并返回产品 b2
//   构建产品 b2
//   客户端正在请求工厂客户端再次运行
//   工厂客户端正在运行抽象产品 b
//   产品 b2: 8388608 正在与产品 a: 7340032 交互
//+------------------------------------------------------------------+
//|输出 > 生成器                                                                                                  
//+------------------------------------------------------------------+
//   Creational::Builder::Client::Output
//   客户端请求创建一个新的具体构建器
//   客户端请求创建一个主管并给他构建器
//  主管创建并接收了构建器 10485760
//   客户请求主管进行施工
//  主管已开始施工
//  主管正在请求其构建者构建产品部件
//   构建器请求产品将 a 部分添加到自身
//   产品将 a 部分添加到自身中
//   构建者已制作了 A 部分并将其添加到产品中
//   构建器请求产品将 b 部分添加到自身
//   产品将 b 部分添加到自身中
//   建造者已经制作了 b 部分并将其添加到产品中
//   构建器请求产品将 c 部分添加到自身
//   产品将 c 部分添加到自身中
//   建造者已经制作了 c 部分并将其添加到产品中
//   导演的建造者用零件建造了产品
//   客户端请求构建器返回结果产品
//   构建者正在返回产品
//   客户正在请求描述其本身的产品
//   产品显示其组成的所有部件
//  a部分
//   b 部分
//  c 部分
//+------------------------------------------------------------------+
//|输出 > 工厂方法                                         |
//+------------------------------------------------------------------+
//   Creational::FactoryMethod::Client::Output
//   请求创建创建者
//   请求创建者运行其工厂方法以返回产品
//   创建者正在运行工厂方法
//   具体创建者正在创建并返回新的具体产品
//   具体产品：已创建 15728640
//   请求创建者运行其操作
//   创建者正在运行其操作
//   创建者正在运行工厂方法
//   具体创建者正在创建并返回新的具体产品
//   具体产品：已创建 16777216
//   创建者已保存从虚拟工厂方法收到的产品
//+------------------------------------------------------------------+
//|输出 > 原型                                              |
//+------------------------------------------------------------------+
//   Creational::Prototype::Client::Output
//   请求创建一个 id 为 1 的具体原型 1
//   原型 18874368，id: 1 创建
//   具体原型 1: 18874368, id: 1 创建
//   请求原型 18874368 创建其克隆
//   克隆具体原型 1: 18874368, id: 1
//   原型 19922944，id：1 已创建
//   具体原型 1: 19922944, id: 1 创建
//   请求创建一个 id 为 2 的具体原型 2
//   原型 20971520，id: 2 创建
//   具体原型 2: 20971520, id: 2 创建
//   请求原型 20971520 创建其克隆
//   克隆具体原型 2: 20971520, id: 2
//   原型 22020096，id: 2 已创建
//   具体原型 2: 22020096, id: 2 创建
//+------------------------------------------------------------------+
//|输出 > 单例                                               |
//+------------------------------------------------------------------+
//   Creational::Singleton::Client::Output
//   请求单例实例 1
//   单例实例方法正在运行
//   单例的唯一实例为空
//   单例 24117248 创建
//   分配给唯一实例的单例
//   唯一实例包含单例：24117248
//   返回单例的唯一实例 24117248
//   请求单例实例 2
//   单例实例方法正在运行
//   唯一实例包含单例：24117248
//   返回单例的唯一实例 24117248
//   实例 1 和实例 2 是相同的对象
//   请求实例 1 上的单例操作
//   运行单例操作 > 设置单例数据
//   通过单例实例 2 请求单例数据
//   读取并返回单例数据
//   单例数据
//+------------------------------------------------------------------+

附件下载

📎 pattern.mq5 (7.04 KB)

📎 patternorganizer.mqh (12.4 KB)

📎 abstractfactory.mqh (37.03 KB)

📎 builder.mqh (14.65 KB)

📎 factorymethod.mqh (9.85 KB)

📎 prototype.mqh (22.08 KB)

📎 singleton.mqh (8.94 KB)

Source: MQL5 #30597