## 引言

**桥接模式**是一种结构型设计模式，它可以将一个大类或一组相关的类拆分成抽象和实现两个独立的层次结构，从而可以在两个层次结构中分别变化。桥接模式的核心思想是“尽可能将抽象部分和实现部分分离，使它们可以独立地变化”。这样可以使得系统更加灵活，易于扩展和维护。



在桥接模式中，有两个重要的角色：抽象部分和实现部分。抽象部分定义了一组抽象接口，它们与实现部分相互作用；实现部分则提供了这些接口的具体实现。


## 实现

1. 定义抽象部分的接口或抽象类


```csharp
public interface IShape
{
    void Draw();
}
```

2 .定义实现部分的接口或抽象类


```csharp
public interface IColor
{
    void Fill();
}
```
3. 实现实现部分的具体类


```csharp
public class Red : IColor
{
    public void Fill()
    {
        Console.WriteLine("Fill with red color.");
    }
}

public class Blue : IColor
{
    public void Fill()
    {
        Console.WriteLine("Fill with blue color.");
    }
}

```
4. 实现抽象部分的具体类，并在其中包含实现部分的对象

```csharp
public abstract class Shape
{
    protected IColor color;

    public Shape(IColor color)
    {
        this.color = color;
    }

    public abstract void Draw();
}

public class Circle : Shape
{
    public Circle(IColor color) : base(color)
    {
    }

    public override void Draw()
    {
        Console.Write("Draw a circle. ");
        color.Fill();
    }
}

public class Rectangle : Shape
{
    public Rectangle(IColor color) : base(color)
    {
    }

    public override void Draw()
    {
        Console.Write("Draw a rectangle. ");
        color.Fill();
    }
}

```
5. 客户端调用


```csharp
IColor red = new Red();
IColor blue = new Blue();

Shape circle = new Circle(red);
circle.Draw();

Shape rectangle = new Rectangle(blue);
rectangle.Draw();
```
6. 输出：
```csharp
Draw a circle. Fill with red color.
Draw a rectangle. Fill with blue color.
```
在上面的代码中，我们定义了两个实现部分的具体类 `Red` 和 `Blue`，它们实现了 `IColor` 接口。然后我们定义了两个抽象部分的具体类 `Circle` 和 `Rectangle`，并在它们的构造函数中传入一个 `IColor` 对象，实现了抽象部分和实现部分的解耦。最后，在客户端代码中使用抽象部分，通过传入不同的实现部分对象来实现不同的功能
## 结论

桥接模式的优点在于它可以让抽象部分和实现部分各自独立地变化，从而可以更加灵活地组合它们。此外，它还可以减少类之间的耦合度，提高代码的可维护性和可扩展性。

重温设计模式 --- 桥接模式

## 引言
**外观模式**是一种结构型设计模式，它为客户端提供了一个简单的接口，使得客户端能够更容易地使用复杂的子系统。外观模式通过隐藏子系统的复杂性，简化了客户端的调用过程，同时也降低了客户端与子系统的耦合度。



外观模式的核心思想是将系统的各个组件和子系统封装在一个单独的类中，称为外观类。外观类为客户端提供一个简单的接口，隐藏了系统的复杂性。客户端只需要与外观类交互，就可以使用系统的所有功能。

:::tip{title="提示"}
将外观模式具象化可以这样理解，假设我们有一个汽车工厂，它可以生产各种型号的汽车。生产一辆汽车需要很多步骤，比如设计、采购零件、组装等等。如果客户端要使用汽车工厂生产一辆汽车，那么他需要了解所有这些步骤的细节，这会使得客户端非常复杂。但是如果我们在汽车工厂的外面加上一个售车大厅，**这个售车大厅就是外观**。客户端只需要在售车大厅告诉售货员他想要什么型号的汽车，然后售货员会帮他完成所有的操作。这样客户端就可以很方便地使用汽车工厂了。
:::

接下来，我们使用C#实现上文描述的外观模式。

### 子系统类
创建**设计师类**，**采购部类**，**组装车间类**：

```csharp
public class Designer
{
    public void Design()
    {
        //Design a car..
    }
}

public class PurchasingDepartment
{
    public void Purchase()
    {
        //Purchase car parts..
    }
}

public class AssemblyWorkshop
{
    public void Assemble()
    {
        //Assemble car..
    }
}

```
### 外观类
创建外观类：

```csharp
public class CarFacade
{
    private Designer designer;
    
    private PurchasingDepartment purchasingDepartment;
    
    private AssemblyWorkshop assemblyWorkshop;

    public CarFacade()
    {
        designer = new();
        
        purchasingDepartment = new();
        
        assemblyWorkshop = new();
    }

    public void Operation()
    {
        designer.Design();
        
        purchasingDepartment.Purchase();
        
        assemblyWorkshop.Assemble();
        
        //othre Operation ..
    }
}

```
这样，客户端需要一辆车的时候，只需要这样

```csharp
Facade facade = new Facade();

facade.Operation();
```

上述示例中，`Designer`，`PurchasingDepartment`，`AssemblyWorkshop`是三个子系统类，`CarFacade`是外观类，`CarFacade`封装了子系统的复杂性，为客户提供了一个简单的接口`Operation`,而无需了解其实现细节。

## 结论
外观模式通常用于大型系统中，其中有多个子系统相互依赖，而客户端只需要使用其中一小部分功能。
它可以帮助客户端更容易地使用这些功能，而无需了解子系统的所有细节。
它通过将客户端代码与复杂的子系统代码解耦，简化了客户端与子系统之间的交互。

重温设计模式 --- 外观模式

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


在代理模式中，有三个核心角色：**抽象主题（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`方法，这样客户端就达到了通过适配器调用原有类的方法。

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