## 引言

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



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

### 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（图形用户界面）开发、事件驱动系统、消息通知系统、进程间通信等场景中。

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

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

重温设计模式 --- 观察者模式

## 引言
**单例模式**是一种创建型设计模式，它的主要目的是确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。在许多情况下，单例模式是非常有用的，比如说当你需要创建一个全局的配置类或者日志类时，单例模式可以让你轻松地实现这些功能。

在实现单例模式时，有两种常见的方法，“懒汉式”和“饿汉式”

### 懒汉式


```csharp
public class Singleton
{
    private static Singleton instance;
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        if(instance == null)
        {
            instance = new Singleton();
        }
        return instance;
    }
}

```

这种方式的特点是只有在需要的时候才会创建实例，而不是在类加载的时候就创建实例。这种方式可以节省系统资源，但是可能会影响性能。


### 懒汉式（双检锁）

上文中的实现方案中，并未考虑到线程安全，要确保在多线程环境下只有一个实例被创建，需要**使用双重检查锁定**，双检锁/双重校验锁（DCL，即 double-checked locking）。

```csharp
public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();

    private Singleton()
    {
        // 私有构造函数
    }

    public static Singleton GetInstance()
    {
        if (instance == null)
        {
            lock (lockObject)
            {
                if (instance == null)
                {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

```
### 饿汉式


```csharp
public class Singleton
{
    private static Singleton instance = new Singleton();
    
    private Singleton()
    {
        // 私有构造函数
    }
    
    public static Singleton GetInstance()
    {
        return instance;
    }
}

```

这种方式的特点是在类加载的时候就创建实例，而不是在需要的时候才创建实例。这种方式可以保证线程安全，但是可能会浪费系统资源。

在使用“饿汉式”方式实现单例模式时，实例是在类加载时创建的。因此，不需要使用额外的线程安全技术。

## 总结
总的来说，单例模式是一种常见的设计模式，它能够确保某个类在应用程序中只有一个实例，并且这个实例能够被全局访问。但在使用“懒汉式”实现时，要注意线程安全问题。

重温设计模式 --- 单例模式

## 引言
**抽象工厂模式**一种创建型设计模式，它提供了一种方式来封装一组具有相同主题的工厂，而不必指定它们具体的类。这样，客户端代码就可以使用抽象工厂来创建一组相关的对象，而不必关心实际创建的具体类。


抽象工厂模式有以下几个主要角色：
- 抽象工厂（AbstractFactory）：声明用于创建抽象产品的操作的接口。

- 工厂实现（ConcreteFactory）：实现创建具体产品对象的操作。

- 抽象产品（AbstractProduct）：声明产品对象类型的接口。

- 产品实现（Product）：定义由相应的具体工厂创建的产品对象，实现AbstractProduct接口。

下面使用C#实现抽象工厂模式:

### 抽象工厂
定义一个抽象工厂接口，其中包含了创建不同产品的方法：
```csharp
public interface IAbstractFactory
{
    IProductA CreateProductA();
    IProductB CreateProductB();
}

```
### 工厂实现
定义具体的工厂类，实现抽象工厂接口：
```csharp
public class ConcreteFactory1 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA1();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB1();
    }
}

public class ConcreteFactory2 : IAbstractFactory
{
    public IProductA CreateProductA()
    {
        return new ConcreteProductA2();
    }

    public IProductB CreateProductB()
    {
        return new ConcreteProductB2();
    }
}

```
在上述示例中，我们定义了两个具体工厂类：`ConcreteFactory1`和`ConcreteFactory2`。这两个工厂类都实现了`IAbstractFactory`接口，并且分别提供了不同的产品实现。
### 抽象产品
```csharp
public interface IProductA
{
    string GetName();
}
```
### 产品实现
```csharp
public class ConcreteProductA1 : IProductA
{
    public string GetName()
    {
        return "ProductA1";
    }
}

public class ConcreteProductA2 : IProductA
{
    public string GetName()
    {
        return "ProductA2";
    }
}

public interface IProductB
{
    string GetName();
}

public class ConcreteProductB1 : IProductB
{
    public string GetName()
    {
        return "ProductB1";
    }
}

public class ConcreteProductB2 : IProductB
{
    public string GetName()
    {
        return "ProductB2";
    }
}
```

下面，我们可以使用抽象工厂来创建一组相关的对象：

```csharp
public class Client
{
    private IAbstractFactory factory;

    public Client(IAbstractFactory factory)
    {
        this.factory = factory;
    }

    public void Run()
    {
        var productA = factory.CreateProductA();
        var productB = factory.CreateProductB();

        Console.WriteLine(productA.GetName());
        Console.WriteLine(productB.GetName());
    }
}

static void Main(string[] args)
{
    var client1 = new Client(new ConcreteFactory1());
    client1.Run();

    var client2 = new Client(new ConcreteFactory2());
    client2.Run();
}
```
输出：

```csharp
ProductA1
ProductB1

ProductA2
ProductB2
```

## 总结

上面的示例中，我们使用抽象工厂模式来创建了一组相关的对象，但是需要注意的是，它适用于创建一组相关的产品对象，但是当产品族的变化引起整个工厂等级结构的变化时，抽象工厂模式就不适用了。

此外，抽象工厂模式还存在一些缺点，例如：
- 新增产品会导致工厂接口的扩展。如果需要新增产品，就需要修改所有的工厂类，这会带来一些不必要的麻烦。

- 可能会导致类层次结构的复杂度增加。如果有多个产品族，就需要定义多个工厂接口，这会增加类层次结构的复杂度。

因此，在使用抽象工厂模式时，需要根据具体情况进行权衡和选择。