# DesignPattern

**Repository Path**: Ruemo/design-pattern

## Basic Information

- **Project Name**: DesignPattern
- **Description**: 设计模式练习
- **Primary Language**: C#
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-09-16
- **Last Updated**: 2025-03-28

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

**Gitee无法渲染Mermaid绘制的UML类图，请使用VSCode或者其他IDE安装插件查看**

参考链接：
1. https://www.cnblogs.com/zhili/p/DesignPatternSummery.html
2. https://github.com/sheng-jie/Design-Pattern/tree/master

# 预热

关于UML的类图以及使用Mermaid绘制UML类图

UML类图示例

![img](./Assets/Demo.png)

Mermaid绘制UML类图

Mermaid是一个基于JavaScript的工具，它允许您使用类似于Markdown的语法来生成图表和流程图。以下是使用Mermaid绘制类图的基本步骤和语法：

### 基本语法

类图在Mermaid中是通过以下语法来定义的：

```
classDiagram
    类定义1
    类定义2
    ...
    关系定义1
    关系定义2
    ...
```

### 类定义

类定义的基本格式如下：

```
class 类名 {
  属性1: 类型
  属性2: 类型
  方法1(): 返回类型
  方法2(): 返回类型
}
```

### 关系定义

类之间的关系可以通过以下语法表示：

* classA --|> classB : Inheritance泛化
* classC --* classD : Composition组合
* classE --o classF : Aggregation聚合
* classG --> classH : Association关联
* classK ..> classL : Dependency依赖
* classM ..|> classN : Realization实现
* classI -- classJ : Link(Solid)
* classO .. classP : Link(Dashed)

~~~ mermaid
classDiagram
    classA --|> classB : Inheritance泛化
    classC --* classD : Composition组合
    classE --o classF : Aggregation聚合
    classG --> classH : Association关联
    classK ..> classL : Dependency依赖
    classM ..|> classN : Realization实现
    classI -- classJ : Link(Solid)
    classO .. classP : Link(Dashed)
~~~

### 示例

以下是一个简单的类图示例：

```mermaid
classDiagram
    class Animal {
      +name: String
      +age: int
      +eat(): void
      +sleep(): void
    }
    class Dog {
      +bark(): void
    }
    class Cat {
      +meow(): void
    }
    Animal <|-- Dog
    Animal <|-- Cat
```

在这个示例中，`Animal` 是一个基类，它有两个属性（`name` 和 `age`）以及两个方法（`eat` 和 `sleep`）。`Dog` 和 `Cat` 是从 `Animal` 继承而来的子类，它们分别有自己的方法 `bark` 和 `meow`。`Dog` 和 `Cat` 与 `Animal` 之间的关系是继承关系。



# 23种设计模式简述

## 创建型模式

### [单例模式](https://www.jianshu.com/p/2054c44dcd5a)

简述：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

~~~ mermaid
---
title: Singleton Pattern
---
classDiagram
    direction BT
    class Singleton {
        +instance: Singleton
        +getInstance(): Singleton
        +method(): void
    }
    Singleton --o Singleton
~~~



### [工厂方法模式](https://www.jianshu.com/p/1275b99ca973) 

简述：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

~~~ mermaid
---
title: Factory Method Pattern
---
classDiagram
	direction BT
    class Creator {
      +factoryMethod(): Product
    }
    class ConcreteCreatorA {
      +factoryMethod(): ConcreteProductA
    }
    class ConcreteCreatorB {
      +factoryMethod(): ConcreteProductB
    }
    class Product {
    }
    class ConcreteProductA {
    }
    class ConcreteProductB {
    }
    Product <|.. ConcreteProductA
    Product <|.. ConcreteProductB
    Creator <|-- ConcreteCreatorA
    Creator <|-- ConcreteCreatorB
    ConcreteCreatorA ..> ConcreteProductA : creates
    ConcreteCreatorB ..> ConcreteProductB : creates
~~~

包含简单工厂模式、工厂方法模式、抽象工厂模式和反射工厂模式

### [抽象工厂模式]()

简述：为创造一组相关或相互用来的对象提供一个接口，而且无需指定他们的具体类。

~~~ mermaid
---
title: Abstract Factory Pattern
---
classDiagram
    direction BT

    class AbstractFactory {
        +createProductA(): AbstractProductA
        +createProductB(): AbstractProductB
    }

    class ConcreteFactory1 {
        +createProductA(): ProductA1
        +createProductB(): ProductB1
    }

    class ConcreteFactory2 {
        +createProductA(): ProductA2
        +createProductB(): ProductB2
    }

    class AbstractProductA {
    }

    class ProductA1 {
    }

    class ProductA2 {
    }

    class AbstractProductB {
    }

    class ProductB1 {
    }

    class ProductB2 {
    }

    AbstractFactory <|-- ConcreteFactory1
    AbstractFactory <|-- ConcreteFactory2
    AbstractProductA <|.. ProductA1
    AbstractProductA <|.. ProductA2
    AbstractProductB <|.. ProductB1
    AbstractProductB <|.. ProductB2
    ConcreteFactory1 --> AbstractProductA
    ConcreteFactory1 --> AbstractProductB
    ConcreteFactory2 --> AbstractProductA
    ConcreteFactory2 --> AbstractProductB

~~~



### [建造者模式](https://www.jianshu.com/p/c5811ca1d208)

简述：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

~~~ mermaid
---
title: Builder Pattern
---
classDiagram
    direction BT

    class Product {
        -partA: String
        -partB: String
        -partC: String
        +setPartA(partA: String): void
        +setPartB(partB: String): void
        +setPartC(partC: String): void
        +show(): void
    }

    class Builder {
        +buildPartA(): void
        +buildPartB(): void
        +buildPartC(): void
        +getResult(): Product
    }

    class ConcreteBuilder {
        -product: Product
        +buildPartA(): void
        +buildPartB(): void
        +buildPartC(): void
        +getResult(): Product
    }

    class Director {
        -builder: Builder
        +construct(): void
    }

    Builder <|.. ConcreteBuilder
    Director --> Builder
    ConcreteBuilder --> Product

~~~



### [原型模式](https://www.jianshu.com/p/ce7b981708b4)

简述：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

~~~ mermaid
---
title: Prototype Pattern
---
classDiagram
    direction BT

    class Prototype {
        +clone(): Prototype
    }

    class ConcretePrototype {
        -field1: String
        -field2: String
        +clone(): Prototype
    }

    class Client {
        +operation(prototype: Prototype): Prototype
    }

    Prototype <|.. ConcretePrototype
    Client --> Prototype

~~~



## 结构型模式

### 代理模式

简述：为其他对象提供一种代理以控制这个对象的访问。

~~~ mermaid
---
title: Proxy Pattern
---
classDiagram
    direction BT

    class Subject {
        +request(): void
    }

    class RealSubject {
        +request(): void
    }

    class Proxy {
        -realSubject: RealSubject
        +request(): void
    }

    class Client {
        +main(): void
    }

    Subject <|.. RealSubject
    Subject <|.. Proxy
    Proxy --> RealSubject
    Client --> Proxy

~~~



### [适配器模式](https://www.jianshu.com/p/5e5f5024c62e)

简述：将一个类的接口变换成客户端所期待的另一种接口，从而使得原本因为接口不匹配而无法一起工作的两个类能够在一起工作。

~~~ mermaid
---
title: Adapter Pattern
---
classDiagram
    direction BT

    class Target {
        +request(): String
    }

    class Adaptee {
        +specificRequest(): String
    }

    class Adapter {
        -adaptee: Adaptee
        +request(): String
    }

    class Client {
        +main(target: Target): void
    }

    Target <|.. Adapter
    Adapter --> Adaptee
    Client --> Target

~~~



### [装饰模式](https://www.jianshu.com/p/246041fc39a4)

简述：动态地给一个对象添加一些额外的职责。就增加功能来说，它相比生成子类更灵活。

装饰器模式在最开始的接口中是将所有能"增强"的方法事先定义好，而后对这些方法进行"Push_Front"或"Push_Back"方式的增强，而不会增加原始接口中方法的数量。并且注意装饰模式只用来装饰方法或者说函数。而对于例如Java的注解（Annotation）和C#的特性（Attribute）只是形式上是相似的但是实现的原理并不相同。

~~~ mermaid
---
title: Decorator Pattern
---
classDiagram
    direction BT

    class Component {
        +operation(): String
    }

    class ConcreteComponent {
        +operation(): String
    }

    class Decorator {
        -component: Component
        +operation(): String
    }

    class ConcreteDecoratorA {
        -additionalState: String
        +operation(): String
    }

    class ConcreteDecoratorB {
        -additionalState: String
        +operation(): String
    }

    class Client {
        +main(component: Component): void
    }

    Component <|.. ConcreteComponent
    Component <|.. Decorator
    Decorator <|.. ConcreteDecoratorA
    Decorator <|.. ConcreteDecoratorB
    ConcreteDecoratorA --> Component
    ConcreteDecoratorB --> Component
    Client --> Component

~~~



### [桥接模式](https://www.jianshu.com/p/d0314ebb0617)

简述：将抽象和实现解耦，使得两者可以独立变化。

~~~ mermaid
---
title: Bridge Pattern
---
classDiagram
    direction BT

    class Abstraction {
        -implementation: Implementation
        +operation(): void
    }

    class RefinedAbstraction {
        -implementation: Implementation
        +operation(): void
        +refinedOperation(): void
    }

    class Implementation {
        +operationImp(): void
    }

    class ConcreteImplementationA {
        +operationImp(): void
    }

    class ConcreteImplementationB {
        +operationImp(): void
    }

    class Client {
        +main(abstraction: Abstraction): void
    }

    Abstraction --> Implementation
    RefinedAbstraction --> Implementation
    Implementation <|.. ConcreteImplementationA
    Implementation <|.. ConcreteImplementationB
    Client --> Abstraction
    Client --> RefinedAbstraction

~~~



### [外观模式](https://www.jianshu.com/p/c89a922a60c0)

简述：要求一个子类的外部与其内部的通信必须通过一个统一的对象进行。外观模式提供一个高层次的接口，使得子系统更易于使用。

~~~ mermaid
---
title: Facade Pattern
---
classDiagram
    direction BT

    class Facade {
        +operation(): void
    }

    class Subsystem1 {
        +operation1(): void
    }

    class Subsystem2 {
        +operation2(): void
    }

    class Subsystem3 {
        +operation3(): void
    }

    class Client {
        +main(facade: Facade): void
    }

    Facade --> Subsystem1
    Facade --> Subsystem2
    Facade --> Subsystem3
    Client --> Facade

~~~



### [组合模式](https://www.jianshu.com/p/9e49e5d702df)

简述：将对象组合成树形结构以表示**部分与整体**的层次结构，使得用户对单个对象和组合对象操作具有一致性。

~~~ mermaid
---
title: Composite Pattern
---
classDiagram
    direction BT

    class Component {
        +operation(): void
    }

    class Leaf {
        +operation(): void
    }

    class Composite {
        -children: List<Component>
        +operation(): void
        +add(component: Component): void
        +remove(component: Component): void
        +getChild(index: int): Component
    }

    class Client {
        +main(component: Component): void
    }

    Component <|.. Leaf
    Component <|.. Composite
    Composite --> Component
    Client --> Component

~~~



### [享元模式](https://www.jianshu.com/p/3fb0b559602b)

简述：使用共享对象可有效地支持大量细粒度的对象。

~~~ mermaid
---
title: Flyweight Pattern
---
classDiagram
    direction BT

    class Flyweight {
        +operation(extrinsicState: String): void
    }

    class ConcreteFlyweight {
        +operation(extrinsicState: String): void
    }

    class UnsharedConcreteFlyweight {
        +operation(extrinsicState: String): void
    }

    class FlyweightFactory {
        +getFlyweight(key: String): Flyweight
    }

    class Client {
        +main(): void
    }

    Flyweight <|.. ConcreteFlyweight
    Flyweight <|.. UnsharedConcreteFlyweight
    FlyweightFactory --> Flyweight
    Client --> FlyweightFactory

~~~



## 行为型模式

### [模板方法模式](https://www.jianshu.com/p/4c8d1a0a75e1)

简述：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定的步骤。

~~~ mermaid
---
title: Template Method Pattern
---
classDiagram
    direction BT

    class AbstractClass {
        +templateMethod(): void
        +primitiveOperation1(): void
        +primitiveOperation2(): void
    }

    class ConcreteClassA {
        +primitiveOperation1(): void
        +primitiveOperation2(): void
    }

    class ConcreteClassB {
        +primitiveOperation1(): void
        +primitiveOperation2(): void
    }

    AbstractClass <|.. ConcreteClassA
    AbstractClass <|.. ConcreteClassB

~~~



### [策略模式](https://www.jianshu.com/p/390fd50d02b8)

简述：定义一组算法，将每个算法都封装起来，并且使它们之间可以相互替换。

~~~ mermaid
---
title: Strategy Pattern
---
classDiagram
    direction BT

    class Strategy {
        +algorithmInterface(): void
    }

    class ConcreteStrategyA {
        +algorithmInterface(): void
    }

    class ConcreteStrategyB {
        +algorithmInterface(): void
    }

    class Context {
        -strategy: Strategy
        +setStrategy(strategy: Strategy): void
        +algorithmInterface(): void
    }

    class Client {
        +main(context: Context): void
    }

    Strategy <|.. ConcreteStrategyA
    Strategy <|.. ConcreteStrategyB
    Context --> Strategy
    Client --> Context

~~~



### 命令模式

简述：把一个请求或者操作封装在命令对象中。命令模式允许系统使用不同的请求把客户端参数化，对请求排队或者记录目录，可以提供命令的撤销和恢复功能。

~~~ mermaid
---
title: Command Pattern
---
classDiagram
    direction BT

    class Command {
        +execute(): void
    }

    class ConcreteCommand {
        -receiver: Receiver
        +execute(): void
    }

    class Receiver {
        +action(): void
    }

    class Invoker {
        -command: Command
        +setCommand(command: Command): void
        +executeCommand(): void
    }

    class Client {
        +main(): void
    }

    Command <|.. ConcreteCommand
    ConcreteCommand --> Receiver
    Invoker --> Command
    Client --> Invoker

~~~



### [责任链模式](https://www.jianshu.com/p/95908acb842a)

简述：使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链转递该请求，直到有对象处理它为止。

~~~mermaid
---
title: Chain of Responsibility Pattern
---
classDiagram
    direction BT

    class HandlerBase
    class ConcreteHandler1
    class ConcreteHandler2
    
    class Request{
        -info: string
        +getInfo(): string
    }
    
    class HandlerBase {
        +setSuccessor(Handler successor)
        +handleRequest(Request request)
    }   

    class ConcreteHandler1 {
        +handleRequest(Request request)
    }

    class ConcreteHandler2 {
        +handleRequest(Request request)
    }

    class Request {
        +getInfo() : string
    }

    class Client {
        +main(): void
    }
    
    HandlerBase <|-- ConcreteHandler1
    HandlerBase <|-- ConcreteHandler2
    HandlerBase <|-- ConcreteHandler3
    ConcreteHandler1 --o ConcreteHandler2
    ConcreteHandler2 --o ConcreteHandler3
    Request --> HandlerBase
    Client --> HandlerBase
~~~



### [状态模式](https://www.jianshu.com/p/42d4ca7316ad)

简述：当一个对象内在状态改变时允许其改变行为，这个对象看起来是改变了其类。

~~~ mermaid
---
title: State Pattern
---
classDiagram
    direction BT

    class Context {
        -state: State
        +request1(): void
        +request2(): void
    }

    class State {
        +handle(context: Context): void
    }

    class ConcreteStateA {
        +handle(context: Context): void
    }

    class ConcreteStateB {
        +handle(context: Context): void
    }

    class Client {
        +main(): void
    }

    State <|.. ConcreteStateA
    State <|.. ConcreteStateB
    Context --> State
    Client --> Context

~~~



### [观察者模式](https://www.jianshu.com/p/45675c73296d)

简述：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖与它的对象都会得到通知并被自动更新。

~~~ mermaid
---
title: Observer Pattern
---
classDiagram
    direction BT

    class Subject {
        -observers: List<Observer>
        +attach(observer: Observer): void
        +detach(observer: Observer): void
        +notify(): void
    }

    class ConcreteSubject {
        +attach(observer: Observer): void
        +detach(observer: Observer): void
        +notify(): void
    }

    class Observer {
        +update(subject: Subject): void
    }

    class ConcreteObserverA {
        +update(subject: Subject): void
    }

    class ConcreteObserverB {
        +update(subject: Subject): void
    }

    class Client {
        +main(): void
    }

    Subject <|.. ConcreteSubject
    Observer <|.. ConcreteObserverA
    Observer <|.. ConcreteObserverB
    ConcreteSubject --> Observer
    Client --> ConcreteSubject

~~~



### [中介者模式](https://www.jianshu.com/p/d37cd087a06f)

简述：用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变他们之间的交互。

~~~ mermaid
---
title: Mediator Pattern
---
classDiagram
    direction BT

    class Mediator {
        +register(colleague: Colleague): void
        +unregister(colleague: Colleague): void
        +notify(colleague: Colleague, message: String): void
    }

    class ConcreteMediator {
        +register(colleague: Colleague): void
        +unregister(colleague: Colleague): void
        +notify(colleague: Colleague, message: String): void
    }

    class Colleague {
        -mediator: Mediator
        +send(message: String): void
    }

    class ConcreteColleagueA {
        +send(message: String): void
    }

    class ConcreteColleagueB {
        +send(message: String): void
    }

    class Client {
        +main(): void
    }

    Mediator <|.. ConcreteMediator
    Colleague <|.. ConcreteColleagueA
    Colleague <|.. ConcreteColleagueB
    ConcreteMediator --> Colleague
    Client --> ConcreteMediator

~~~



### [迭代器模式](https://www.jianshu.com/p/ae229f72c522)

简述：提供一种方法访问一个容器对象中各个元素，而又无需暴露该对象的内部细节。

~~~ mermaid
---
title: Iterator Pattern
---
classDiagram
    direction BT

    class Iterator {
        +next(): Object
        +hasNext(): boolean
        +previous(): Object
        +first(): void
        +last(): void
        +currentItem(): Object
    }

    class ConcreteIterator {
        +next(): Object
        +hasNext(): boolean
        +previous(): Object
        +first(): void
        +last(): void
        +currentItem(): Object
    }

    class Aggregate {
        -items: List<Object>
        +createIterator(): Iterator
    }

    class ConcreteAggregate {
        -items: List<Object>
        +createIterator(): Iterator
    }

    class Client {
        +main(): void
    }

    Iterator <|.. ConcreteIterator
    Aggregate <|.. ConcreteAggregate
    ConcreteAggregate --> Iterator
    Client --> ConcreteAggregate

~~~



### [访问器模式](https://www.jianshu.com/p/3aa45b6be7ae)

简述：封装一些作用于某种数据结构的各元素的操作，它可以在不改变数据结构的前提下定义作用于这些元素的新操作。

访问器模式用来对"同祖先"的对象进行统一操作

~~~ mermaid
---
title: Visitor Pattern
---
classDiagram
    direction BT

    class Visitor {
        +visit(element: Element): void
    }

    class ConcreteVisitor {
        +visit(element: Element): void
    }

    class Element {
        +accept(visitor: Visitor): void
    }

    class ConcreteElementA {
        +accept(visitor: Visitor): void
    }

    class ConcreteElementB {
        +accept(visitor: Visitor): void
    }

    class Client {
        +main(): void
    }

    Visitor <|.. ConcreteVisitor
    Element <|.. ConcreteElementA
    Element <|.. ConcreteElementB
    ConcreteElementA --> Visitor
    ConcreteElementB --> Visitor
    Client --> ConcreteVisitor

~~~



### [备忘录模式](https://www.jianshu.com/p/6d46b5d3fdee)

简述：在不破坏封装性的前提下，捕获一个对象的内部状态，并且在该对象之外保存这个状态。这样以后就可将该对象恢复到原先的状态。

~~~ mermaid
---
title: Memento Pattern
---
classDiagram
    direction BT

    class Memento {
        +getState(): Object
        +setState(state: Object): void
    }

    class ConcreteMemento {
        +state: Object
        +getState(): Object
        +setState(state: Object): void
    }

    class Originator {
        -memento: Memento
        +createMemento(): Memento
        +getState(): Object
        +setState(state: Object): void
    }

    class ConcreteOriginator {
        +state: Object
        +createMemento(): Memento
        +getState(): Object
        +setState(state: Object): void
    }

    class Caretaker {
        -memento: Memento
        +getMemento(): Memento
        +setMemento(memento: Memento): void
    }

    class ConcreteCaretaker {
        +memento: Memento
        +getMemento(): Memento
        +setMemento(memento: Memento): void
    }

    class Client {
        +main(): void
    }

    Memento <|.. ConcreteMemento
    Originator <|.. ConcreteOriginator
    Caretaker <|.. ConcreteCaretaker
    ConcreteOriginator --> ConcreteMemento
    ConcreteCaretaker --> ConcreteMemento
    Client --> ConcreteOriginator

~~~



### 解释器模式

简述：给定一种语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

~~~ mermaid
---
title: Interpret Pattern
---
classDiagram
    direction BT

    class AbstractExpression {
        +interpret(context: Context): void
    }

    class TerminalExpression {
        +interpret(context: Context): void
    }

    class NonterminalExpression {
        +interpret(context: Context): void
    }

    class Context {
        +evaluate(expression: AbstractExpression): void
    }

    class Client {
        +main(): void
    }

    AbstractExpression <|.. TerminalExpression
    AbstractExpression <|.. NonterminalExpression
    Context --> AbstractExpression
    Client --> Context

~~~



# 其他设计模式

[Unity3D中的各种设计模式](https://github.com/QianMo/Unity-Design-Pattern) 位于UnityGameProgrammingPatterns.zip中，可使用Unity运行。

* 子类沙盒模式
* 类型对象模式
* 组件模式
* 事件队列模式
* 游戏循环模式
* 服务定位器模式
* 数据局部性模式
* 脏标记模式
* 对象池模式

《设计模式之禅》补充

* 规格模式