## 引言
软件开发过程中，我们经常会遇到各种设计问题，例如如何管理对象之间的关系、如何优化代码的可复用性和可维护性等等。为了解决这些问题，我们可以使用设计模式。



设计模式是一种被广泛接受的软件设计思想，它提供了一套通用的解决方案，可以帮助我们更好地解决常见的软件设计问题。设计模式是从实践中总结出来的，它不仅可以提高代码的可读性和可维护性，还可以提高开发效率和代码的可复用性。

## 常见设计模式原则
设计模式有常见的五大原则 - [SOLID](https://niuery.com/post/9)
- 单一职责原则（SRP）
- 开放封闭原则（OCP）
- 里氏替换原则（LSP）
- 接口隔离原则（DIP）
- 依赖倒置原则（ISP）


补充第六原则，迪米特法则(Law of Demeter,LoD)也称为最少知识原则(Least Knowledge Principle,LKP)

## 常见设计模式类型
- 创建型模式：负责对象的创建和初始化，共有5种：**工厂方法模式**、**抽象工厂模式**、**单例模式**、**建造者模式**、**原型模式**。
- 结构型模式：负责对象的组合，共有7种：**适配器模式**、**装饰器模式**、**代理模式**、**外观模式**、**桥接模式**、**组合模式**、**享元模式**。
- 行为型模式：负责对象之间的通信，共有11种：**观察者模式**、**策略模式**、**迭代器模式**、**命令模式**、**责任链模式**、**模板方法模式**、**访问者模式**、**中介者模式**、**解释器模式**、**过滤器模式**、**备忘录模式**。
## 目录

### 创建型模式

1. [**抽象工厂模式（Abstract Factory Pattern）**](https://niuery.com/post/10)

抽象工厂模式是一种创建型设计模式，它提供了一种封装一组相关或相互依赖对象创建过程的方法，使得我们可以在不知道具体实现细节的情况下，创建一系列相互协作的对象。

2. [**工厂方法模式（Factory Method Pattern）**](https://niuery.com/post/33)

工厂方法模式是一种创建型设计模式，它提供了一种将对象的创建过程封装起来的方法，使得我们可以在不知道具体实现细节的情况下，创建各种不同类型的对象。

3. [**单例模式（Singleton Pattern）**](https://niuery.com/post/11)

单例模式是一种保证一个类只有一个实例的模式，它可以避免多个实例造成的资源浪费和对象的不一致性。单例模式通常使用一个私有的构造函数和一个静态的实例变量来实现。

4. [**建造者模式（Builder Pattern）**](https://niuery.com/post/13)

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式可以将复杂对象的构建过程抽象出来，从而使得系统更加灵活。

5. [**原型模式（Prototype Pattern）**](https://niuery.com/post/14)

用原型实例指定创建对象的种类，并通过复制这些原型创建新的对象。原型模式可以在运行时动态地创建对象，从而避免了静态工厂方法所带来的编译时耦合。


### 结构型模式
1. [**适配器模式（Adapter Pattern）**](https://niuery.com/post/15)

适配器模式是一种将一个类的接口转换成客户端所期望的另一种接口的模式，它可以让原本不兼容的类能够协同工作。这种模式可以避免因接口不匹配而导致的代码重构和重复开发。

2. [**装饰器模式（Decorator Pattern）**](https://niuery.com/post/16)

装饰器模式是一种在运行时动态地给对象添加新的功能的模式，它通过将对象包装在一个装饰器中来实现。这种模式可以避免使用继承带来的复杂性和静态特性，提高代码的灵活性和可扩展性。

3. [**代理模式（Proxy Pattern）**](https://niuery.com/post/17)

代理模式是一种结构型设计模式，它允许我们创建一个代理对象来控制对另一个对象的访问。代理对象可以充当原始对象的访问接口，从而控制对原始对象的访问。代理模式通常用于远程访问、延迟加载、访问控制等方面。

4. [**外观模式（Facade Pattern）**](https://niuery.com/post/18)

为一组复杂的子系统提供一个简单的接口，从而隐藏子系统的复杂性。外观模式可以降低客户端和子系统之间的耦合度，同时提高客户端的易用性。

5. [**桥接模式（Bridge Pattern）**](https://niuery.com/post/19)

桥接模式是一种将抽象部分与它的实现部分分离开来的模式，使它们可以独立地变化。这种模式可以避免因为实现细节的变化而导致的代码修改和重构。

6. [**组合模式（Composite Pattern）**](https://niuery.com/post/20)

组合模式是一种将对象组合成树形结构的模式，使得客户端可以像处理单个对象一样处理对象的组合。这种模式可以使得对象之间的关系更加清晰，提高代码的可读性和可维护性。

7. [**享元模式（Flyweight Pattern）**](https://niuery.com/post/21)

享元模式是一种结构型设计模式，用于优化对象的创建和使用。该模式通过共享相同的数据，来减少内存的使用和对象的创建。通常情况下，享元模式适用于存在大量相似对象的情况

### 行为型模式

1. [**观察者模式（Observer Pattern）**](https://niuery.com/post/12)

观察者模式是一种对象间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会收到通知并自动更新。这种模式可以降低对象之间的耦合度，提高系统的灵活性和可扩展性。

2. [**策略模式（Strategy Pattern）**](https://niuery.com/post/22)

策略模式是一种定义一系列算法的模式，它将每个算法封装在一个类中，并使它们可以互相替换。这种模式可以避免使用大量的条件语句和重复代码，提高代码的可维护性和可扩展性。

3. [**迭代器模式（Iterator Pattern）**](https://niuery.com/post/23)

迭代器模式是一种访问一个聚合对象中的各个元素的方式，而又不需要暴露该对象的内部表示。这种模式可以让客户端透明地访问聚合对象中的元素，同时避免了聚合对象的数据结构对客户端的依赖。

4. [**命令模式（Command Pattern）**](https://niuery.com/post/25)

将请求封装成对象，从而使不同的请求可以被不同的对象处理。命令模式可以将请求的发送者和接收者解耦，同时支持请求的撤销和重做

5. [**责任链模式（Chain of Responsibility Pattern）**](https://niuery.com/post/26)

将请求的发送者和接收者解耦，通过一条由多个处理对象组成的链来处理请求。责任链模式可以根据需求动态地组合处理对象，从而实现请求的自动转发和处理。

6. [**模板方法模式（Template Method Pattern）**](https://niuery.com/post/27)

定义一个操作中的算法骨架，将一些步骤延迟到子类中。模板方法模式可以提高代码的复用性和可维护性，同时可以避免子类中的代码重复

7. [**状态模式（State Pattern）**](https://niuery.com/post/28)

允许对象在内部状态发生改变时改变它的行为。状态模式将对象的行为和状态进行分离，从而将复杂的条件判断转化为简单的状态切换。

8. [**中介者模式（Mediator Pattern）**](https://niuery.com/post/29)

用一个中介对象来封装一系列的对象交互，从而使对象之间的交互松散耦合。中介者模式可以简化对象之间的交互，同时降低对象之间的依赖关系。

9. [**解释器模式（Interpreter Pattern）**](https://niuery.com/post/30)

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。解释器模式可以将复杂的语言转化为易于处理的数据结构，从而使得语言的解释更加容易。

10. [**访问者模式（Visitor Pattern）**](https://niuery.com/post/31)

访问者模式是一种行为设计模式，它可以让你将算法与它们操作的对象分离。这样，你可以在不修改对象结构的情况下，向现有的对象结构添加新的操作。

11. [**备忘录模式（Memento Pattern）**](https://niuery.com/post/32)
备忘录模式是一种行为型设计模式，它允许我们将对象的状态保存在备忘录对象中，从而可以在以后恢复对象的状态。该模式通常用于需要撤销、恢复操作的场景，例如文本编辑器、绘图应用等。备忘录模式通过将状态保存在备忘录对象中来实现状态的恢复，从而保证了对象的封装性和数据安全性。

重温设计模式 --- 前篇

## 引言
**工厂方法模式**是一种创建型设计模式，它定义了一个用于创建对象的接口，但是让子类决定将哪一个类实例化。换句话说，工厂方法模式让一个类的实例化延迟到其子类。



工厂方法模式有以下几个主要角色：

- 抽象工厂（AbstractFactory）：声明用于创建抽象产品的操作的接口。

- 工厂实现（ConcreteFactory）：实现创建具体产品对象的操作。

- 抽象产品（AbstractProduct）：声明产品对象类型的接口。

- 产品实现（Product）：定义由相应的具体工厂创建的产品对象，实现AbstractProduct接口。

下面使用c#实现一个工厂方法模式：

### 抽象工厂

```csharp
public abstract class Factory
{
    public abstract Product CreateProduct();
}
```
### 工厂实现

```csharp
// 具体工厂类
public class ConcreteFactoryA : Factory
{
    public override Product CreateProduct()
    {
        return new ConcreteProductA();
    }
}

public class ConcreteFactoryB : Factory
{
    public override Product CreateProduct()
    {
        return new ConcreteProductB();
    }
}
```
### 抽象产品

```csharp
// 抽象产品类
public abstract class Product
{
    public abstract void ShowInfo();
}
```
### 产品实现

```csharp
// 具体产品类
public class ConcreteProductA : Product
{
    public override void ShowInfo()
    {
        Console.WriteLine("This is product A.");
    }
}

public class ConcreteProductB : Product
{
    public override void ShowInfo()
    {
        Console.WriteLine("This is product B.");
    }
}
```
下面可以这样调用：

```csharp
 Factory factoryA = new ConcreteFactoryA();
 Product productA = factoryA.CreateProduct();
 productA.ShowInfo();
 
 Factory factoryB = new ConcreteFactoryB();
 Product productB = factoryB.CreateProduct();
 productB.ShowInfo();
```
输出：

```csharp
This is product A.
This is product B.
```


在上面的示例中，`Product` 是抽象产品类，`ConcreteProductA` 和 `ConcreteProductB` 是具体产品类，`Factory` 是抽象工厂类，`ConcreteFactoryA` 和 `ConcreteFactoryB` 是具体工厂类。客户端代码使用工厂类创建产品对象，并调用其方法。

## 总结

当需要添加新的产品时，只需创建一个新的具体产品类，并实现抽象产品类中的抽象方法即可。当需要添加新的工厂时，只需创建一个新的具体工厂类，并实现抽象工厂类中的抽象方法即可。这样，客户端代码就不需要改变。这也是工厂方法模式的一个重要优点，它让代码更加灵活，易于扩展和维护。

重温设计模式 --- 工厂方法模式

## 引言
**备忘录模式**是一种行为型设计模式，它允许你捕获对象的内部状态，并在不暴露其实现细节的情况下将其保存在外部对象中，从而可以在以后的某个时间点将该对象恢复到先前的状态。




备忘录模式有以下几个主要角色：
- **Originator（原发器）**：是需要被保存状态的对象。它可以创建一个Memento对象来存储它的当前状态，并从Memento对象中恢复它之前的状态。

- **Memento（备忘录）**：存储Originator的内部状态。只有Originator可以访问和修改它的状态，外部对象不能访问和修改它。

- **Caretaker（管理者）**：负责保存和恢复Originator的状态。它保存了Originator的历史状态列表，并提供了一个接口来保存和恢复这些状态。


这些角色协同工作，使得Originator对象可以在不暴露其实现细节的情况下保存和恢复其状态。备忘录模式提供了一种灵活的方式，可以在多个时间点保存对象的状态，并可以在以后的某个时间点恢复到任何先前的状态。

下面使用c#实现一个简单备忘录模式：
### 定义原发器类


```csharp
public class Originator
{
    private string state;

    public string State
    {
        get { return state; }
        set 
        { 
            state = value; 
            Console.WriteLine("State set to: " + state); 
        }
    }

    public Memento SaveState()
    {
        return new Memento(state);
    }

    public void RestoreState(Memento memento)
    {
        state = memento.State;
        Console.WriteLine("State restored to: " + state);
    }
}

```

### 定义备忘录

```csharp
public class Memento
{
    private string state;

    public Memento(string stateToSave)
    {
        state = stateToSave;
    }

    public string State
    {
        get { return state; }
    }
}

```

### 定义管理者

```csharp
public class Caretaker
{
    private List<Memento> mementoList = new List<Memento>();

    public void SaveState(Memento state)
    {
        mementoList.Add(state);
    }

    public Memento RestoreState(int stateNumber)
    {
        return mementoList[stateNumber];
    }
}
```
调用代码：

```csharp
Originator originator = new Originator();
Caretaker caretaker = new Caretaker();

originator.State = "State 1";
originator.State = "State 2";
caretaker.SaveState(originator.SaveState());

originator.State = "State 3";
caretaker.SaveState(originator.SaveState());

originator.State = "State 4";
Console.WriteLine("Current state: " + originator.State);

// 恢复到之前的状态
originator.RestoreState(caretaker.RestoreState(1));
Console.WriteLine("Restored state: " + originator.State);
```

输出结果：

```csharp
State set to: State 1
State set to: State 2
State set to: State 3
State set to: State 4
Current state: State 4
State restored to: State 3
Restored state: State 3
```
在这个例子中，`Originator`是一个保存状态的对象，它的状态被保存到`Memento`对象中。`Caretaker`保存了`Originator`的历史状态列表，并提供了保存和恢复这些状态的方法。当需要恢复之前的状态时，`Caretaker`通过调用`RestoreState`方法来获取`Memento`对象，并将其传递给`Originator`的`RestoreState`方法，从而将Originator恢复到之前的状态。

## 结论
备忘录模式的优点是它可以在不暴露对象实现细节的情况下保存和恢复对象的状态。它还允许对象在多个时间点保存它的状态，并恢复到之前的任何时间点。缺点是如果保存的状态非常大，它可能会占用大量的内存。此外，备忘录模式会增加代码的复杂性和开销。

在实际应用中，备忘录模式通常与其他模式一起使用，例如命令模式和状态模式，以实现更复杂的行为。

重温设计模式 --- 备忘录模式

## 引言

**访问者模式**是一种行为型设计模式，它允许你在不修改对象结构的前提下定义作用于这些对象元素的新操作。它主要解决了在不修改已有类的前提下，对已有类中的对象进行新操作的问题。


访问者模式有以下几个主要角色：
- 访问者（Visitor）：访问者角色是一个抽象类或接口，其中定义了访问每个被访问元素时所需要执行的操作。具体访问者角色则实现了访问者接口，并根据需要实现其操作。


- 被访问元素（Element）：被访问元素角色是一个抽象类或接口，其中定义了接受访问者访问的接口。具体的被访问元素角色则实现了被访问元素接口，并实现其方法。

下面使用C#实现一个访问者模式：
### 定义访问者

```csharp
// 访问者接口
interface IVisitor
{
    void Visit(ElementA element);
    void Visit(ElementB element);
}

// 具体访问者1
class ConcreteVisitor1 : IVisitor
{
    public void Visit(ElementA element)
    {
        Console.WriteLine("ConcreteVisitor1 is visiting ElementA");
    }

    public void Visit(ElementB element)
    {
        Console.WriteLine("ConcreteVisitor1 is visiting ElementB");
    }
}

// 具体访问者2
class ConcreteVisitor2 : IVisitor
{
    public void Visit(ElementA element)
    {
        Console.WriteLine("ConcreteVisitor2 is visiting ElementA");
    }

    public void Visit(ElementB element)
    {
        Console.WriteLine("ConcreteVisitor2 is visiting ElementB");
    }
}
```
在上面的示例中，访问者角色由接口`IVisitor`表示，其中定义了`Visit`方法，用于访问被访问元素。具体访问者`ConcreteVisitor1`和`ConcreteVisitor2`则实现了`IVisitor`接口，并根据需要实现了`Visit`方法。
### 定义被访问元素

```csharp
// 被访问元素接口
interface IElement
{
    void Accept(IVisitor visitor);
}

// 具体被访问元素A
class ElementA : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }
}

// 具体被访问元素B
class ElementB : IElement
{
    public void Accept(IVisitor visitor)
    {
        visitor.Visit(this);
    }
}
```
被访问元素角色由接口IElement表示，其中定义了Accept方法，用于接受访问者的访问。具体的被访问元素ElementA和ElementB则实现了IElement接口，并实现了Accept方法，其中调用了访问者的Visit方法。

我们可以这样调用：


```csharp
 // 创建被访问元素
 ElementA elementA = new ElementA();
 ElementB elementB = new ElementB();
 
 // 创建访问者
 IVisitor visitor1 = new ConcreteVisitor1();
 IVisitor visitor2 = new ConcreteVisitor2();
 
 // 访问被访问元素
 elementA.Accept(visitor1);
 elementA.Accept(visitor2);
 elementB.Accept(visitor1);
 elementB.Accept(visitor2);
```
输出：

```csharp
ConcreteVisitor1 is visiting ElementA
ConcreteVisitor2 is visiting ElementA
ConcreteVisitor1 is visiting ElementB
ConcreteVisitor2 is visiting ElementB
```

示例中创建了被访问元素ElementA和ElementB，然后创建了访问者visitor1和visitor2。最后，分别调用了被访问元素的Accept方法，以及访问者的Visit方法，完成了访问操作。


:::tip{title="提示"}
需要注意的是，访问者是通过被访问元素的Accept方法进行访问的。因此，在访问者访问一个被访问元素时，该被访问元素会调用访问者的Visit方法，而不是访问者自行调用被访问元素的方法。
:::

## 结论
访问者模式的优点在于，它能够在不修改被访问元素的前提下，定义新的操作。同时，它也符合单一职责原则，因为每个具体的访问者只负责实现一个操作。但是，访问者模式的缺点在于，它增加了系统的复杂度，因为访问者需要了解被访问元素的内部结构，而且在被访问元素的结构发生变化时，需要修改访问者的代码。此外，访问者模式还可能导致循环依赖的问题，因为被访问元素和访问者都需要引用彼此的类。

总的来说，访问者模式是一种灵活的设计模式，可以用于在不修改已有类的前提下，定义新的操作。它的应用场景包括编译器、XML解析器、图形界面组件等需要对对象结构进行操作的系统。

重温设计模式 --- 访问者模式

## 引言

**解释器模式**是一种行为型设计模式，它允许你定义一个语言的文法，并且定义一个解释器来解释该语言中的句子。该模式可以用于编写编译器、计算器、查询语言等应用程序。



解释器模式中有以下三个主要角色：

- **抽象表达式（Abstract Expression）**：它是所有表达式的抽象基类，它声明了一个`Interpret`方法，用于解释表达式。

- **终结符表达式（Terminal Expression**）：它实现了抽象表达式中的 `Interpret`方法，并且代表语言中的终结符（即不再需要解释的元素）。

- **非终结符表达式（Nonterminal Expression）**：它也实现了抽象表达式中的`Interpret`方法，但它代表语言中的非终结符（即需要解释的元素），通常会由多个终结符表达式和/或其他非终结符表达式组合而成。
- **上下文（Content）**：包含解释器的全局信息。

下面使用c#实现一个简单解释器模式：
### 定义抽象表达式类
定义抽象表达式类（AbstractExpression），它包含一个 Interpret 方法，该方法将接受一个 Context 对象，并使用该对象来解释语言中的句子。

```csharp
public abstract class AbstractExpression
{
    public abstract int Interpret(Context context);
}

```

### 定义终结符表达式类
定义终结符表达式类（`TerminalExpression`），它实现了抽象表达式类中的 `Interpret` 方法，并且表示语言中的终结符（即不再需要解释的元素）。在该类中，我们使用 `Context` 对象来获取终结符的值。

```csharp
public class TerminalExpression : AbstractExpression
{
    private string _variable;

    public TerminalExpression(string variable)
    {
        _variable = variable;
    }

    public override int Interpret(Context context)
    {
        return context.GetValue(_variable);
    }
}

```

### 定义非终结符表达式类
定义非终结符表达式类（`NonterminalExpression`），它也实现了抽象表达式类中的 `Interpret` 方法，但它代表语言中的非终结符（即需要解释的元素）。在该类中，我们使用左右两个表达式来计算表达式的值。

```csharp
public class NonterminalExpression : AbstractExpression
{
    private AbstractExpression _leftExpression;
    
    private AbstractExpression _rightExpression;

    public NonterminalExpression(AbstractExpression leftExpression, AbstractExpression rightExpression)
    {
        _leftExpression = leftExpression;
        
        _rightExpression = rightExpression;
    }

    public override int Interpret(Context context)
    {
        int leftValue = _leftExpression.Interpret(context);
        
        int rightValue = _rightExpression.Interpret(context);
        
        return leftValue + rightValue;
    }
}
```

### 定义上下文类

定义一个`Context`类，它保存着当前语言的状态，并且提供一些方法来获取变量的值。

```csharp
public class Context
{
    private Dictionary<string, int> _variables = new Dictionary<string, int>();

    public void SetVariable(string variable, int value)
    {
        _variables[variable] = value;
    }

    public int GetValue(string variable)
    {
        return _variables[variable];
    }
}
```
调用时，构建一个语法树，并且使用 Context 对象来解释句子：


```csharp
Context context = new Context();
context.SetVariable("a", 10);
context.SetVariable("b", 5);
context.SetVariable("c", 15);

AbstractExpression expression = new NonterminalExpression(
    new TerminalExpression("a"),
    new NonterminalExpression(
        new TerminalExpression("b"),
        new TerminalExpression("c")
    )
);

int result = expression.Interpret(context);
Console.WriteLine(result); // 输出：30
```

上面的示例中我们定义了一个简单的语言，它只包含加法运算。我们通过构建一个语法树，并调用解释器来解释语言中的句子，从而实现了解释器模式。

## 结论
解释器模式允许你定义一个语言的语法，并且定义一个解释器来解释该语言中的句子。它可以灵活地扩展语言的语法，只需要添加新的抽象表达式和终止符表达式即可。但是它因为在解释过程中需要对语法树进行遍历，可能会降低程序的性能。