## 引言
**享元模式**是一种结构型设计模式，它允许你在消耗少量内存的情况下支持大量对象。如果你需要生成大量细粒度的类实例来表示数据，而这些实例除了几个参数外基本上都是相同的，那么你可以使用享元模式来 避免大量相似类的开销。



在享元模式中，有两种状态：**内部状态**和**外部状态**。内部状态是存储在享元对象内部的，而外部状态则是在享元对象外部存储的。在使用享元模式时，你可以共享内部状态，而将外部状态作为参数传递给享元对象。

### 抽象享元

```csharp
// 抽象享元类
abstract class Flyweight
{
    public abstract void Operation(int extrinsicState);
}
```

### 具体享元

```csharp
// 具体享元类
class ConcreteFlyweight : Flyweight
{
    private readonly string _intrinsicState;

    public ConcreteFlyweight(string intrinsicState)
    {
        _intrinsicState = intrinsicState;
    }

    public override void Operation(int extrinsicState)
    {
        // 输出内部状态和外部状态
        Console.WriteLine("Intrinsic State = " + _intrinsicState);
        
        Console.WriteLine("Extrinsic State = " + extrinsicState);
    }
}
```

### 享元工厂

```csharp
// 享元工厂类
class FlyweightFactory
{
    private readonly Dictionary<string, Flyweight> _flyweights = new Dictionary<string, Flyweight>();

    public Flyweight GetFlyweight(string key)
    {
        if (_flyweights.ContainsKey(key))
        {
            // 如果已经存在该享元对象，则直接返回该对象
            return _flyweights[key];
        }
        else
        {
            // 如果不存在，则创建一个新的享元对象，并存储在对象池中
            var flyweight = new ConcreteFlyweight(key);
            
            _flyweights.Add(key, flyweight);
            
            return flyweight;
        }
    }
}
```
在这个例子中，我们创建了一个抽象的享元类`Flyweight`，一个具体的享元类`ConcreteFlyweight`和一个享元工厂类`FlyweightFactory`。

在`FlyweightFactory`中，我们使用了一个`Dictionary`来存储享元对象。在`GetFlyweight`方法中，我们首先检查`Dictionary`中是否已经存在了一个享元对象。如果存在，我们就返回这个对象。否则，我们就创建一个新的享元对象，并将其添加到`Dictionary`中。

可以这样调用：

```csharp
FlyweightFactory factory = new FlyweightFactory();

Flyweight flyweight1 = factory.GetFlyweight("A");

flyweight1.Operation(1);

Flyweight flyweight2 = factory.GetFlyweight("B");

flyweight2.Operation(2);

Flyweight flyweight3 = factory.GetFlyweight("A");

flyweight3.Operation(3);
```
输出：

```csharp
Intrinsic State = A
Extrinsic State = 1

Intrinsic State = B
Extrinsic State = 2

Intrinsic State = A
Extrinsic State = 3
```
从输出中就可以看出，享元A的内部状态是共享的，`Operation`更新的只是外部状态。
## 结论
享元模式所带来的优势：
- 相同对象只需要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。
- 享元模式可以避免大量相似类的开销。在软件开发中，如果需要生成大量细粒度的类实例来表示数据，如果这些实例除了几个参数外基本上都是相同的，这时候就可以使用享元模式来大幅度减少需要实例化类的数量。
- 享元模式可以提高系统资源的利用率。由于享元模式可以减少系统中对象的数量，因此可以减少系统资源的占用，提高系统的性能。

重温设计模式 --- 享元模式

## 引言
**组合模式**是一种结构型设计模式，它允许你将对象组合成树形结构来表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性，因为它们都具有相同的接口。



组合模式由三个要素组成：

1. **抽象组件（Component）**：它定义了叶子节点和组合节点的公共接口，可以为叶子节点和组合节点提供默认实现。

2. **叶子组件（Leaf）**：它表示组合的叶子节点，没有子节点。

3. **组合组件（Composite）**：它表示组合的内部节点，可以包含叶子节点或其他组合节点。

### 抽象组件


```csharp
// 抽象组件类
abstract class Component
{
    protected string name;

    public Component(string name)
    {
        this.name = name;
    }

    public abstract void Add(Component c);
    
    public abstract void Remove(Component c);
    
    public abstract void Display(int depth);
}
```

### 叶子组件

```csharp
// 叶子节点类
class Leaf : Component
{
    public Leaf(string name) : base(name)
    {
    }

    public override void Add(Component c)
    {
        Console.WriteLine("Cannot add to a leaf");
    }

    public override void Remove(Component c)
    {
        Console.WriteLine("Cannot remove from a leaf");
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);
    }
}
```
### 组合组件

```csharp
// 组合节点类
class Composite : Component
{
    private List<Component> children = new List<Component>();

    public Composite(string name) : base(name)
    {
    }

    public override void Add(Component c)
    {
        children.Add(c);
    }

    public override void Remove(Component c)
    {
        children.Remove(c);
    }

    public override void Display(int depth)
    {
        Console.WriteLine(new String('-', depth) + name);

        foreach (Component component in children)
        {
            component.Display(depth + 1);
        }
    }
}
```
在上面的示例中，`Component`是抽象组件类，包含了组合模式中共有的方法。`Leaf`是叶子节点类，表示树状结构中的叶子节点，而`Composite`是组合节点类，表示树状结构中的组合节点。

可以这样调用：

```csharp
Composite root = new Composite("root");

root.Add(new Leaf("leaf A"));

root.Add(new Leaf("leaf B"));

Composite composite = new Composite("composite X");

composite.Add(new Leaf("leaf XA"));

composite.Add(new Leaf("leaf XB"));

root.Add(composite);

root.Add(new Leaf("leaf C"));

root.Display(0);
```

客户端代码创建了一个根节点`root`，并向它添加了三个子节点：两个叶子节点和一个组合节点`composite`。组合节点`composite`又包含了两个叶子节点。最后，客户端代码调用根节点的`Display`方法，打印出整个树状结构。

输出结果如下：

```csharp
root
-leaf A
-leaf B
-composite X
--leaf XA
--leaf XB
-leaf C
```
## 总结
组合模式的关键是定义了一个抽象组件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象组件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象组件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

重温设计模式 --- 组合模式

## 引言

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



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


## 实现

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
- 不更改现有代码的情况下添加线程安全功能