## 引言
**装饰器模式**是一种结构型设计模式，它允许在不改变原始对象的情况下，通过将其包装在一个装饰器对象中，来动态地添加额外的功能。


装饰器模式的核心思想是，将一个对象放在另一个对象的外面，以给原始对象添加新的行为。这个“另一个对象”就是装饰器（Decorator），它持有一个原始对象（Component）的引用，并实现与原始对象相同的接口。装饰器可以通过调用原始对象的方法，来执行自己的行为。这种方式可以动态地添加、删除或替换对象的行为，而不需要修改原始对象的代码。

### 基本类接口

定义一个基本对象接口或抽象类，称为`Component`，它定义了一些基本操作：
```csharp
//定义基本对象接口
public interface IComponent
{
    void Operation();
}
```

### 基本类实现
定义一个实现`IComponent`接口的具体类：

```csharp
//IComponent接口的实现类
public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("ConcreteComponent.Operation()");
    }
}

```
### 装饰器抽象
定义一个装饰器抽象类或接口，称为`Decorator`，它也实现了`Component`接口，并在其中添加了一些新的操作：

```csharp
//装饰器抽象
public abstract class Decorator : IComponent
{
    private IComponent component;

    public Decorator(IComponent component)
    {
        this.component = component;
    }

    public virtual void Operation()
    {
        component.Operation();
    }
}
```
### 装饰器实现

```csharp
//实现多个装饰器类
public class ConcreteDecoratorA : Decorator
{
    public ConcreteDecoratorA(IComponent component) : base(component)
    {
    
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorA.Operation()");
    }
}

public class ConcreteDecoratorB : Decorator
{
    public ConcreteDecoratorB(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("ConcreteDecoratorB.Operation()");
    }
}
```
接着，我们可以创建并使用一个具有特定功能对象：

```csharp
IComponent component = new ConcreteComponent();

IComponent decoratorA = new ConcreteDecoratorA(component);

IComponent decoratorB = new ConcreteDecoratorB(decoratorA);

decoratorB.Operation();
```
输出如下：

```csharp
ConcreteComponent.Operation()

ConcreteDecoratorA.Operation()

ConcreteDecoratorB.Operation()
```

上文例子中，我们创建了一个基本对象`ConcreteComponent`,并创建了两个装饰器`ConcreteDecoratorA`和`ConcreteDecoratorB`，最后，我们使用这些装饰器来创建一个具有特定功能的对象，并调用它的操作方法。输出结果显示，这个对象实际上执行了多个操作，包括基本操作和添加的操作。

:::tip{title="提示"}
装饰器模式有一些缺点。首先，它可能会导致对象数量的增加，因为每个装饰器都需要一个单独的对象。其次，由于装饰器可以相互嵌套，因此在创建复杂的装饰器结构时可能会变得难以理解和维护。
:::



## 结论
装饰器模式的优点是它可以动态地添加对象的新行为，而无需改变其原始类。这样，我们可以通过组合不同的装饰器来创建多种对象变体，同时保持原始对象的完整性和一致性。且装饰器模式遵循开放/封闭原则，因为它允许我们添加新的功能，而无需修改现有代码。

重温设计模式 --- 装饰器模式

## 引言

**适配器模式**是一种结构型设计模式，用于将一个类的接口转换成另一个接口，以便于两个不兼容的类之间能够协同工作。适配器模式可以被认为是一个桥梁，它可以连接两个不同的接口，从而使得它们可以进行协同工作。


适配器模式通常在两个不兼容的类之间进行转换，这些类可能具有不同的接口，不同的数据类型或不同的方法签名。适配器模式通过将一个类的接口转换为另一个类的接口来解决这个问题，这样这两个不同的类就可以协同工作了。

适配器模式分为两种类型，类适配器模式和对象适配器模式。

- **类适配器模式**：通过多重继承的方式，将适配者类的接口转换为目标接口。

- **对象适配器模式**：通过组合的方式，将适配者类的接口转换为目标接口。

下面我们使用C#来实现适配器模式。


### 创建目标接口

```csharp
// 目标接口
public interface ITarget
{
    void Request();
}
```

### 创建原有类

```csharp
// 原有类
public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee.SpecificRequest");
    }
}
```


###  类适配器模式

类适配器模式通过继承实现适配器功能，它继承了原有类并实现了新的接口。这样，客户端就可以通过适配器调用原有类的方法。

1. 创建类适配器

```csharp
// 类适配器
public class Adapter : Adaptee, ITarget
{
    public void Request()
    {
        this.SpecificRequest();
    }
}
```
2. 创建客户端

```csharp
// 客户端代码
public class Client
{
    public void DoWork(ITarget target)
    {
        target.Request();
    }
}
```

可以这样调用：

```csharp
// 使用类适配器模式
Client client = new Client();

ITarget adapter = new Adapter();

client.DoWork(adapter);
```


适配器`Adapter`继承原有类`Adaptee`，实现了`ITarget`接口，并在`Request`方法中调用了基类的`SpecificRequest`方法，这样客户端就达到了通过适配器调用原有类的方法。

### 对象适配器模式

对象适配器模式通过组合实现适配器功能，它将原有类的对象作为一个成员变量包含在适配器类中。这样，客户端就可以通过适配器调用原有类的方法。

```csharp
// 对象适配器
public class Adapter : ITarget 
{
    private Adaptee adaptee;
    
    public Adapter(Adaptee adaptee)
    {
        this.adaptee = adaptee;
    }
    
    public void Request() 
    {
        this.adaptee.SpecificRequest();
    }
}
```
2. 创建客户端

```csharp
// 客户端代码
public class Client
{
    public void DoWork(ITarget target)
    {
        target.Request();
    }
}
```

可以这样调用：

```csharp
Client client = new Client();

Adaptee adaptee = new Adaptee();

ITarget adapter = new Adapter(adaptee);

client.DoWork(adapter);
```
适配器`Adapter`实现了`ITarget`接口，并持有了原有类的对象作为一个成员变量，使用含参构造的方式将原有类对象初始化，在`Request`方法中调用了原有类的`SpecificRequest`方法，这样客户端就达到了通过适配器调用原有类的方法。

## 结论
如果我们需要在现有代码中添加新的功能，而又不能修改原有的代码，那么适配器模式就是一个非常好的解决方案。适配器模式可以将不兼容的接口转换成兼容的接口，从而让不兼容的代码能够协同工作。

重温设计模式 --- 适配器模式

## 引言

**原型模式**是一种创建型设计模式，它允许我们创建一个对象的副本，而不需要显式地使用构造函数来创建一个新的对象。这种模式通常用于创建那些具有复杂创建过程或需要大量资源的对象。



在原型模式中，我们首先定义一个原型接口，该接口包含一个克隆方法。然后我们创建一个原型对象，该对象实现了原型接口并提供了自己的克隆方法。最后，我们可以使用原型对象的克隆方法来创建新的对象，而无需重新实例化原型对象。

### IClone接口

需要定义一个`IClone`接口。这个类中应该包含一个 `Clone` 方法，用于克隆自身。

```csharp
public interface IClone<T> where T : class
{
    public T Clone();
}
```
### 原型类
定义一个具体原型类，它实现`IClone`接口，并实现了`Clone`方法

```csharp
public class ConcretePrototype : IClone<ConcretePrototype>
{
    private string _name;

    public ConcretePrototype(string name)
    {
        _name = name;
    }

    public ConcretePrototype Clone()
    {
        return (ConcretePrototype)this.MemberwiseClone();
    }

    public void SetName(string name)
    {
        _name = name;
    }

    public void PrintName()
    {
        Console.WriteLine($"Name: {_name}");
    }
}
```

在具体原型类中，我们实现了 `Clone` 方法，并使用了 `MemberwiseClone` 方法来复制对象。此外，我们还添加了一个 `SetName` 方法和一个 `PrintName` 方法，用于演示对象的复制和修改。


:::tip{title="提示"}
1. 使用 `Clone` 方法来复制对象。需要注意的是，在复制对象时，我们需要使用 `MemberwiseClone` 方法或其他**深拷贝**方法来复制对象本身，而不是复制它的引用。此外，如果需要复制对象的引用类型成员，我们需要在具体原型类中对它们进行**深拷贝**。
2. 原型模式是在内存二进制流的拷贝，要比直接`new`一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
3. 执行`Clone`方法复制对象时，**不执行其构造函数**。
:::

接下来，我们可以使用具体原型类来创建新的对象。具体地说，我们可以先创建一个原型对象，然后调用它的 Clone 方法来复制它，并修改复制出的对象的状态。

```csharp
ConcretePrototype prototype = new ConcretePrototype("prototype");

ConcretePrototype clone = (ConcretePrototype)prototype.Clone();

prototype.PrintName(); // Name: prototype

clone.PrintName(); // Name: prototype

clone.SetName("clone");

prototype.PrintName(); // Name: prototype

clone.PrintName(); // Name: clone

```
在这段代码中，我们首先创建了一个名为 `prototype` 的具体原型对象，并输出它的名字。然后，我们调用了 `prototype` 的 `Clone` 方法来复制它，并将结果保存在名为 `clone` 的变量中。接着，我们修改了 `clone` 的名字为 "clone"，并分别输出 `prototype` 和 `clone` 的名字，以证明它们是不同的对象。

## 总结

原型模式适用于以下情况：

- 当需要创建的对象的类型由程序在运行时确定时，原型模式比工厂模式更加灵活。
- 当需要创建的对象的创建过程较为复杂，或者需要初始化较长时间时，原型模式可以避免重复创建对象的开销。
- 当需要创建的对象与其它对象具有相似的属性和方法时，原型模式可以避免重复编写相同的代码。

重温设计模式 --- 原型模式

## 引言

**建造者模式**是一种创建型设计模式，它可以将一个复杂对象的构建过程和表示分离，使得相同的构建过程可以创建不同的表示，以及不同的构建过程可以创建相同的表示



在实际的开发中，我们有时需要创建一些复杂的对象，例如包含多个组件和属性的对象，这时候如果直接在代码中创建对象，代码的可读性和可维护性都会降低。而使用建造者模式可以将对象的创建过程封装在一个建造者类中，使得代码更加清晰和易于维护。

下面我们使用C#语言来实现建造者模式。我们以创建一台电脑为例，电脑包含CPU、内存、硬盘等组件。

### 组件类

首先我们需要定义电脑的组件类：

```csharp
public class CPU
{
    public string Type { get; set; }
}

public class Memory
{
    public int Size { get; set; }
}

public class HardDisk
{
    public int Capacity { get; set; }
}
```
### 复杂目标类

定义一个电脑类，该类包含CPU、内存、硬盘等组件：

```csharp
public class Computer
{
    public CPU CPU { get; set; }
    
    public Memory Memory { get; set; }
    
    public HardDisk HardDisk { get; set; }
}

```
### 建造者类
定义一个建造者类，该类用于创建电脑对象：

```csharp
public class ComputerBuilder
{
    private Computer _computer = new Computer();

    public ComputerBuilder SetCPU(string type)
    {
        _computer.CPU = new CPU { Type = type };
        return this;
    }

    public ComputerBuilder SetMemory(int size)
    {
        _computer.Memory = new Memory { Size = size };
        return this;
    }

    public ComputerBuilder SetHardDisk(int capacity)
    {
        _computer.HardDisk = new HardDisk { Capacity = capacity };
        return this;
    }

    public Computer Build()
    {
        return _computer;
    }
}
```

在建造者类中，我们定义了`SetCPU`、`SetMemory`、`SetHardDisk`等方法用于设置电脑的各个组件，并且在`Build`方法中返回最终创建的电脑对象。

最后我们可以使用建造者类创建电脑对象：

```csharp
var computerBuilder = new ComputerBuilder();

var computer = computerBuilder
    .SetCPU("Intel Core i7")
    .SetMemory(16)
    .SetHardDisk(512)
    .Build();

```

## 总结
通过使用建造者模式，我们将电脑的创建过程封装在了建造者类中，使得代码更加清晰和易于维护。同时，我们可以通过设置不同的组件来创建不同的电脑对象，使得代码具有更好的可扩展性和复用性。

重温设计模式 --- 建造者模式

## 引言
**观察者模式**是一种行为型设计模式，它允许对象之间建立一种一对多的关系，使得当一个对象状态改变时，所有依赖它的对象都能够自动得到通知并更新自己的状态。该模式可以帮助我们实现松耦合的系统，以便更好地应对变化和扩展。


在观察者模式中，有两个角色：**观察者**和**被观察者**。被观察者负责维护观察者列表，并在状态发生改变时通知观察者；观察者则负责接收被观察者的通知并进行相应的处理。

下面我们通过一个简单的例子来说明观察者模式的用法。假设我们要实现一个计数器，每次计数器增加时需要通知所有的观察者。

### 观察者

先定义一个接口`IObserver`，用于定义观察者的行为，该接口只有一个方法`Update`，用于接收被观察者的通知并更新观察者的状态。

```csharp
public interface IObserver
{
    void Update(int count);
}
```
再定义一个观察者实现`ConsoleObserver`，它负责在控制台上输出计数器的值。

```csharp
public class ConsoleObserver : IObserver
{
    public void Update(int count)
    {
        Console.WriteLine($"Count = {count}");
    }
}

```


### 被观察者
定义一个被观察者`Counter`，它负责维护观察者列表，并在计数器增加时通知观察者。

```csharp
public class Counter
{
    private int count = 0;
    private List<IObserver> observers = new List<IObserver>();

    public void AddObserver(IObserver observer)
    {
        observers.Add(observer);
    }

    public void RemoveObserver(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void Increment()
    {
        count++;
        NotifyObservers();
    }

    private void NotifyObservers()
    {
        foreach (IObserver observer in observers)
        {
            observer.Update(count);
        }
    }
}
```

然后可以定义一个观察者`ConsoleObserver`，一个被观察者`Counter`,再计数器增加时，通知`ConsoleObserver`输出到控制台。

```csharp
Counter counter = new Counter();

IObserver consoleObserver = new ConsoleObserver();

counter.AddObserver(consoleObserver);

counter.Increment();
```
控制台得到输出`Count = 1`。

## 结论
观察者模式广泛应用于GUI（图形用户界面）开发、事件驱动系统、消息通知系统、进程间通信等场景中。

它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，所有依赖于它的观察者对象都会得到通知并自动更新。

观察者模式的作用是将系统中的关注点分离，提高系统的可维护性、扩展性和重用性。通过该模式，主题对象和观察者对象之间的耦合度降低，让它们之间的关系更加松散，从而使系统更加灵活、可扩展和易于维护。