## 引言
**代理模式**是一种结构型设计模式，它允许您提供一个代理来控制对某个对象的访问。在某些情况下，直接访问对象可能会带来一些问题，比如安全问题、性能问题等。代理模式就是为了解决这些问题而设计的。


在代理模式中，有三个核心角色：**抽象主题（Subject）**、 **真实主题（Real Subject）** 和 **代理（Proxy）**。抽象主题是一个接口或抽象类，它定义了真实主题和代理都要实现的方法。真实主题是实现抽象主题接口的类，它执行实际的业务逻辑。代理是也实现了抽象主题接口的类，它包含一个指向真实主题对象的引用，可以在不直接访问真实主题的情况下执行某些操作，比如控制访问权限、记录日志等。
### 抽象主题
定义抽象主题接口：

```csharp
public interface ISubject
{
    void Request();
}
```

### 真实主题
定义真实主题类：

```csharp
public class RealSubject : ISubject
{
    public void Request()
    {
        Console.WriteLine("RealSubject handles request.");
    }
}
```
### 代理类
定义代理类：

```csharp
public class Proxy : ISubject
{
    private RealSubject realSubject;

    public void Request()
    {
        if (realSubject == null)
        {
            realSubject = new RealSubject();
        }

        Console.WriteLine("Proxy handles request.");
        realSubject.Request();
    }
}
```
在代理类中，我们在 `Request`方法中创建一个真实主题对象`RealSubject`（如果它还没有被创建），然后调用真实主题对象的 `Request` 方法。这样，在客户端代码中，我们只需要使用代理对象即可，而不需要直接访问真实主题对象。

客户端调用可以这样调用：

```csharp
Proxy proxy = new Proxy();
proxy.Request();
```

输出：

```csharp
Proxy handles request.
RealSubject handles request.
```

可以看到，代理对象成功地控制了对真实主题对象的访问，并在访问前后添加了额外的逻辑。
## 结论
代理模式主要提供一个代理来控制对某个对象的访问，代理模式通常运用在以下场景：
- 远程访问
- 延迟加载
- 访问控制
- 简化复杂API
- 不更改现有代码的情况下添加线程安全功能

重温设计模式 --- 代理模式

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


装饰器模式的核心思想是，将一个对象放在另一个对象的外面，以给原始对象添加新的行为。这个“另一个对象”就是装饰器（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();

```

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