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




备忘录模式有以下几个主要角色：
- **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
```

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

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

重温设计模式 --- 解释器模式

## 引言

**中介者模式**是一种行为型设计模式，它用于减少对象之间的直接耦合，从而更好地维护代码的可扩展性和可维护性。



在中介者模式中，一个中介者对象封装了一组对象之间的交互逻辑，这些对象通常都有相互关联，但是彼此之间并不直接交互。中介者对象负责协调对象之间的通信，将对象之间的通信逻辑封装在中介者对象中，从而避免对象之间的直接耦合。

中介者模式中有以下几个主要角色：

- 抽象中介者（Mediator）：定义了同事对象之间交互的接口，它通常是一个接口或者抽象类，其中声明了同事对象之间交互所需要的方法。抽象中介者可以用来集中处理同事对象之间的通信，降低系统的耦合度。

- 具体中介者（ConcreteMediator）：实现了抽象中介者接口，通常包含了一个集合用来存储同事对象，实现同事对象之间的协作。具体中介者需要知道所有具体同事类，并从具体同事对象接收消息，向其他具体同事对象发出命令。

- 抽象同事类（Colleague）：定义了同事对象的接口，可以是一个抽象类或者接口，其中定义了一些公共的方法和属性。抽象同事类通常持有一个抽象中介者的引用，以便能够将自己的状态变化通知中介者，同时也可以接收中介者发送的消息。

- 具体同事类（ConcreteColleague）：实现了抽象同事类的接口，是实际的参与者，每个具体同事类都需要知道它的中介者对象，并与其进行交互。具体同事类之间的通信都是通过具体中介者来实现的，它们之间不直接交互。

下面使用C#实现简答中介者模式：
### 抽象中介者

创建抽象中介者接口Mediator，该接口声明了一个方法Send用于发送消息:


```csharp
public interface Mediator
{
    void Send(string message, Colleague colleague);
}
```

### 抽象同事类

创建抽象同事类Colleague，该类声明了一个中介者对象，用于与其他同事类交互：

```csharp
public abstract class Colleague
{
    protected Mediator mediator;

    public Colleague(Mediator mediator)
    {
        this.mediator = mediator;
    }

    public abstract void Send(string message);

    public abstract void Notify(string message);
}
```
### 具体同事类
创建具体同事类ConcreteColleagueA和ConcreteColleagueB，它们实现了抽象同事类Colleague，并实现了发送消息和接收消息的方法：
```csharp
public class ConcreteColleagueA : Colleague
{
    public ConcreteColleagueA(Mediator mediator) : base(mediator)
    {
    }

    public override void Send(string message)
    {
        mediator.Send(message, this);
    }

    public override void Notify(string message)
    {
        Console.WriteLine("ColleagueA received message: " + message);
    }
}

public class ConcreteColleagueB : Colleague
{
    public ConcreteColleagueB(Mediator mediator) : base(mediator)
    {
    }

    public override void Send(string message)
    {
        mediator.Send(message, this);
    }

    public override void Notify(string message)
    {
        Console.WriteLine("ColleagueB received message: " + message);
    }
}
```
### 具体中介者类

创建具体中介者类ConcreteMediator，该类实现了抽象中介者接口Mediator，并维护了一组同事类对象：


```csharp
public class ConcreteMediator : Mediator
{
    private ConcreteColleagueA colleagueA;
    private ConcreteColleagueB colleagueB;

    public ConcreteColleagueA ColleagueA
    {
        set { colleagueA = value; }
    }

    public ConcreteColleagueB ColleagueB
    {
        set { colleagueB = value; }
    }

    public void Send(string message, Colleague colleague)
    {
        if (colleague == colleagueA)
        {
            colleagueB.Notify(message);
        }
        else
        {
            colleagueA.Notify(message);
        }
    }
}

```

可以这样调用：

```csharp
ConcreteMediator mediator = new ConcreteMediator();

ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);

mediator.ColleagueA = colleagueA;
mediator.ColleagueB = colleagueB;

colleagueA.Send("Hello, ColleagueB.");
colleagueB.Send("Hello, ColleagueA.");
```
输出：

```csharp
ColleagueB received message: Hello, ColleagueB.
ColleagueA received message: Hello, ColleagueA.
```

在这个例子中，`ConcreteMediator`充当了中介者的角色，`ConcreteColleagueA`和`ConcreteColleagueB`充当了同事类的角色。当`ConcreteColleagueA`发送消息时，`ConcreteMediator`将消息转发给`ConcreteColleagueB`，`ConcreteColleagueB`将接收到消息并打印在控制台上。当`ConcreteColleagueB`发送消息时，`ConcreteMediator`将消息转发给`ConcreteColleagueA`，`ConcreteColleagueA`将接收到消息并打印在控制台上。这样，`ConcreteColleagueA`和`ConcreteColleagueB`就不需要直接交互，而是通过`ConcreteMediator`来协调它们之间的通信。

## 总结 
在中介者模式中，抽象中介者和抽象同事类是抽象层，而具体中介者和具体同事类是实现层。中介者模式通过将对象之间的通信交给中介者来实现松耦合，从而提高系统的可维护性和可扩展性。

重温设计模式 --- 中介者模式

## 引言

**状态模式**是一种行为型设计模式，它允许对象在其内部状态改变时改变其行为。该模式将对象的行为与其状态分离，并将每种状态封装在不同的类中。这样，对象可以在运行时根据其状态选择不同的行为，而不必在代码中使用大量的条件语句来处理这些状态。


状态模式的优点是它将与特定状态相关的行为局部化并且将状态转换显式化，从而简化了代码，并且使得代码更加容易扩展和维护。但是，使用状态模式可能会增加类的数量，从而增加代码的复杂度。

下面用C#写一个示例，用于更好地说明状态模式的实现。

假设有一个交通信号灯系统，其中包括红灯、黄灯和绿灯三种状态。当交通信号灯处于不同状态时，将显示不同的颜色，并且行人和车辆在这些状态下必须采取不同的行动。这可以使用状态模式来实现。

首先，我们需要定义状态接口，它包含了所有状态必须实现的方法：

### 定义状态接口
定义状态接口，它包含了所有状态必须实现的方法：

```csharp
public interface ITrafficLightState
{
    void Change(TrafficLight trafficLight);
    
    void ReportState();
}

```

### 定义状态实现

实现红灯、黄灯和绿灯状态的具体实现：


```csharp
public class RedLightState : ITrafficLightState
{
    public void Change(TrafficLight trafficLight)
    {
        trafficLight.State = new GreenLightState();
    }

    public void ReportState()
    {
        Console.WriteLine("现在是红灯");
    }
}

public class YellowLightState : ITrafficLightState
{
    public void Change(TrafficLight trafficLight)
    {
        trafficLight.State = new RedLightState();
    }

    public void ReportState()
    {
        Console.WriteLine("现在是黄灯");
    }
}

public class GreenLightState : ITrafficLightState
{
    public void Change(TrafficLight trafficLight)
    {
        trafficLight.State = new YellowLightState();
    }

    public void ReportState()
    {
        Console.WriteLine("现在是绿灯");
    }
}
```
在上述实现中，每个状态都实现了`ITrafficLightState`接口，并在`Change`方法中指定了下一个状态，以及在`ReportState`方法中输出当前状态。

### 定义状态主对象

创建表示交通信号灯的主要对象，并将初始状态设置为红灯：

```csharp
public class TrafficLight
{
    public ITrafficLightState State { get; set; }

    public TrafficLight()
    {
        State = new RedLightState();
    }

    public void ChangeState()
    {
        State.Change(this);
    }

    public void ReportState()
    {
        State.ReportState();
    }
}

```

测试红绿灯状态变化：

```csharp
TrafficLight trafficLight = new TrafficLight();
trafficLight.ReportState();  // 输出 "现在是红灯"

trafficLight.ChangeState();
trafficLight.ReportState();  // 输出 "现在是绿灯"

trafficLight.ChangeState();
trafficLight.ReportState();  // 输出 "现在是黄灯"

trafficLight.ChangeState();
trafficLight.ReportState();  // 输出 "现在是红灯"
```

在这个示例中，我们首先创建了一个`TrafficLight`对象，并将其初始状态设置为红灯。然后，我们调用`ReportState`方法，该方法将输出当前状态。接下来，我们多次调用`ChangeState`方法，该方法将改变当前状态，并再次调用`ReportState`方法以输出新状态。可以看到信号灯在不同的状态下采取了不同的行动。

## 结论

状态模式允许对象在不同的状态下采取不同的行动，并且在状态变化时能够自动转换行为。这种灵活性使得状态模式在许多场景中非常有用，如自动售货机、游戏中的角色状态等。

然而，状态模式也有一些缺点。一个明显的缺点是，如果我们有许多状态，我们需要实现许多具体的状态类，这可能导致代码变得复杂和难以维护。此外，当状态变化不频繁时，状态模式可能过于繁琐，并且可能不值得实现。我们需要根据具体情况权衡其优缺点，以确保在实现时能够最大程度地利用其优势并避免其缺点。