## 引言

**责任链模式**是一种行为型设计模式，它通过一条由多个处理器组成的链来处理请求，每个处理器都有机会处理请求，如果一个处理器不能处理该请求，它会将请求传递给下一个处理器，直到请求被处理为止。


在实际应用中，责任链模式常用于处理请求的分发、事件处理等场景，它的优点在于可以动态地添加、删除处理器，从而灵活地处理请求。

下面使用C#实现的简单责任链模式的示例：

### 抽象处理器类

```csharp
public abstract class Handler
{
    protected Handler successor; //下一个处理器

    public void SetSuccessor(Handler successor)
    {
        this.successor = successor;
    }

    public abstract void HandleRequest(int request);
}
```

### 处理器实现


```csharp
//具体处理器类1
public class ConcreteHandler1 : Handler
{
    public override void HandleRequest(int request)
    {
        if(request >= 0 && request < 10)
        {
            Console.WriteLine("{0} handled request {1}", this.GetType().Name, request);
        }
        else if(successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

//具体处理器类2
public class ConcreteHandler2 : Handler
{
    public override void HandleRequest(int request)
    {
        if(request >= 10 && request < 20)
        {
            Console.WriteLine("{0} handled request {1}", this.GetType().Name, request);
        }
        else if(successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}

//具体处理器类3
public class ConcreteHandler3 : Handler
{
    public override void HandleRequest(int request)
    {
        if(request >= 20 && request < 30)
        {
            Console.WriteLine("{0} handled request {1}", this.GetType().Name, request);
        }
        else if(successor != null)
        {
            successor.HandleRequest(request);
        }
    }
}
```
### 客户端调用

```csharp
//客户端程序
class Client
{
    static void Main(string[] args)
    {
        //构造处理器链
        Handler h1 = new ConcreteHandler1();
        Handler h2 = new ConcreteHandler2();
        Handler h3 = new ConcreteHandler3();
        h1.SetSuccessor(h2);
        h2.SetSuccessor(h3);

        //处理请求
        int[] requests = { 2, 5, 14, 22, 18, 3, 27, 20 };

        foreach (int request in requests)
        {
            h1.HandleRequest(request);
        }

        Console.ReadKey();
    }
}
```

在这个示例中，我们定义了一个抽象处理器类`Handler`和三个具体处理器类`ConcreteHandler1`、`ConcreteHandler2`和`ConcreteHandler3`。在客户端程序中，我们构造了一个处理器链，将`h1`的下一个处理器设置为`h2`，将`h2`的下一个处理器设置为`h3`。然后我们循环处理请求数组中的每个请求，每个请求都从`h1`开始处理。如果一个处理器能够处理该请求，它就会处理该请求并结束；否则它会将请求传递给下一个处理器，直到请求被处理或者没有更多的处理器为止。

## 结论
使用责任链模式的好处在于，我们可以随时增加、删除处理器，而不需要修改客户端程序的代码。

责任链模式也有一些缺点。例如，如果处理器链太长，会降低处理请求的效率；如果处理器之间的依赖关系不清楚，可能会导致处理器重复处理请求或者无法处理请求。因此，在使用责任链模式时需要慎重考虑，根据实际情况选择合适的处理器链长度和处理器之间的依赖关系。

重温设计模式 --- 责任链模式

## 引言
**命令模式**是一种行为型设计模式，它将请求封装成一个对象，从而允许你将不同的请求对客户端参数化，将请求排队或记录请求日志，以及支持可撤销的操作。


在命令模式中，有四个主要角色：

- **接收者（Receiver）**：接收者是实际执行操作的对象。它定义了如何执行与请求相关的操作。
- **命令（Command）**：命令是将请求封装为对象的接口。它包含执行操作的方法，以及可以撤销操作的方法。
- **调用者（Invoker）**：调用者是负责将命令发送给接收者的对象。它包含一个命令对象，并在需要执行命令时调用命令的 Execute 方法。
- **客户端（Client）**：客户端是使用命令模式的对象。它创建具体的命令对象，并将命令对象传递给调用者，从而实现将请求封装为对象的目的。
- 
下面用c#做一个命令模式示例，它实现了一个简单的遥控器：

### 接收者

```csharp
// 接收者：电视
class TV
{
    public void TurnOn()
    {
        Console.WriteLine("The TV is on.");
    }

    public void TurnOff()
    {
        Console.WriteLine("The TV is off.");
    }
}
```
### 命令

```csharp
// 命令接口
interface ICommand
{
    void Execute();
    void Undo();
}

// 具体命令：打开电视
class TVOnCommand : ICommand
{
    private TV tv;

    public TVOnCommand(TV tv)
    {
        this.tv = tv;
    }

    public void Execute()
    {
        tv.TurnOn();
    }

    public void Undo()
    {
        tv.TurnOff();
    }
}

// 具体命令：关闭电视
class TVOffCommand : ICommand
{
    private TV tv;

    public TVOffCommand(TV tv)
    {
        this.tv = tv;
    }

    public void Execute()
    {
        tv.TurnOff();
    }

    public void Undo()
    {
        tv.TurnOn();
    }
}
```

### 调用者

```csharp
// 调用者：遥控器
class RemoteControl
{
    private ICommand command;

    public void SetCommand(ICommand command)
    {
        this.command = command;
    }

    public void PressButton()
    {
        command.Execute();
    }

    public void PressUndoButton()
    {
        command.Undo();
    }
}
```
### 客户端

```csharp
// 客户端代码
static void Main(string[] args)
{
    TV tv = new TV();
    TVOnCommand tvOn = new TVOnCommand(tv);
    TVOffCommand tvOff = new TVOffCommand(tv);

    RemoteControl remoteControl = new RemoteControl();
    remoteControl.SetCommand(tvOn);
    remoteControl.PressButton(); // 输出：The TV is on.

    remoteControl.SetCommand(tvOff);
    remoteControl.PressButton(); // 输出：The TV is off.

    remoteControl.PressUndoButton(); // 输出：The TV is on.
}
```

在上面的示例中，遥控器是调用者，电视是接收者，`TVOnCommand`和`TVOffCommand`是具体的命令。调用者将命令对象设置到遥控器中，并通过调用`PressButton`方法来执行命令，通过调用`PressUndoButton`方法来撤销命令。当具体的命令被执行时，它会调用接收者的方法来完成特定的操作。

## 结论
命令模式是一种非常实用的设计模式，它可以帮助我们将请求封装成对象，并实现可撤销操作、命令队列、日志和事务等功能，从而简化代码，提高代码的可读性和可维护性。

重温设计模式 --- 命令模式

## 引言

**yield**关键字是 C# 中的一种语言特性，用于在枚举器中简化迭代器的实现。它使得开发人员可以通过定义自己的迭代器来简化代码，而不必手动实现 IEnumerable 和 IEnumerator 接口。



使用 `yield` 关键字，可以将迭代器中的值一次一个地返回，而不必使用一个集合对象存储所有的值。当执行到`yield return`语句时，代码将会暂停执行，将返回值传递给迭代器的调用者，并将迭代器的状态保存下来。当下一次调用`MoveNext`方法时，代码将从之前的暂停点继续执行，直到遇到下一个`yield return`语句或者迭代器结束。

接下来探索一下 `yield` 的三种玩法：
## 初级

例如通过 `yield` 创建出一个 `IEnumerable` 以供 `foreach` 遍历，代码如下：

```csharp
internal class Program
{
    static void Main(string[] args)
    {
        foreach (int i in EvenSequence(5, 18))
        {
            Console.Write(i + " ");
        }

        Console.ReadKey();
    }
    
    static IEnumerable<int> EvenSequence(int start, int end)
    {
        for (int i = start; i <= end; i++)
        {
            if (i % 2 == 0)
            {
                yield return i;
            }
        }
    }
}

```

在上面的代码中，我们定义了一个名为`EvenSequence`的方法，它返回一个实现了`IEnumerable<int>`接口的对象。在`EvenSequence`方法中，我们使用`yield return`语句来返回每个偶数值，并在每次暂停后保存方法的状态。

在`Main`方法中，我们使用`foreach`循环语句来遍历`EvenSequence`方法返回的集合对象，并输出每个偶数值。由于我们使用了 yield 关键字，即使我们没有显式地实现`IEnumerable`和`IEnumerator`接口，也能够遍历集合对象。

## 进阶

另一个方面，**异步编程中也常常使用yield来创建异步生成器**。使用yield创建异步生成器可以让我们轻松地以异步方式生成一系列值，而无需显式地管理异步状态。如以下代码：

```csharp
public class Program
{
    public static void Main(string[] args)
    {
        AsynchronousIterate();

        Console.ReadLine();
    }

    public static async void AsynchronousIterate()
    {
        await foreach (var number in GenerateNumbersAsync())
        {
            Console.WriteLine(number);
        }
    }


    public static async IAsyncEnumerable<int> GenerateNumbersAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(1000);

            yield return i;
        }
    }

}
```
上述代码定义了一个名为 `GenerateNumbersAsync` 的异步方法，该方法返回一个 `IAsyncEnumerable<int>` 类型的对象。在方法体中，我们使用一个 `for` 循环来生成一系列整数，并在每次迭代中异步等待1秒钟。紧接着，我们使用 `yield return` 语句将生成的整数返回给调用方。 要注意调用时使用异步迭代器（具有 `await` 关键字的`foreach`）来进行遍历>。

上述输出则是一秒输出一个结果，知道全部输出。

## 进阶举例场景
现在有这一样一个场景，有一大缸水，你手里有一个水瓢，，现在需要你把水缸里的水，全部移到另一个水缸。

前提条件：现在不知道缸里由具体多少水，也无法确定一瓢能舀多少，也无法确定你每一次舀水操作需要多长时间。

现在写一段代码，模拟这个过程。

拟定前提条件，如下代码：

```csharp
static Random Random = new Random();

/// <summary>
/// 假设水缸能盛水90~100
/// </summary>
public static int GetOneWaterTankCapacity()
{
    return Random.Next(150, 200);
}

/// <summary>
/// 假设水瓢一次只能舀水2~5
/// </summary>
public static int GetOneWaterLadleCapacity()
{
    return Random.Next(2, 5);
}

/// <summary>
/// 模拟舀水所消耗的时间(0.5s~2S)
/// </summary>
/// <returns></returns>
public static async Task<int> ScoopingWater()
{
    await Task.Delay(Random.Next(500, 2000));
    return GetOneWaterLadleCapacity();
}
```

开始舀水，代码如下：

```csharp
/// <summary>
/// 开始搬水
/// </summary>
/// <returns></returns>
public static async void MoveWater()
{
    //先确定缸里有多少水
    var WaterTankCapacity = GetOneWaterTankCapacity();

    await foreach (var item in CreateTasks(WaterTankCapacity))
    {
        Console.WriteLine($"这一瓢舀水量：{item.Result}\t{DateTime.Now}");
    }
    Console.WriteLine($"水全部舀完~\t{DateTime.Now}");
}

private static async IAsyncEnumerable<Task<int>> CreateTasks(int waterTankCapacity)
{
    int totle = 0;
    while (totle < waterTankCapacity)
    {
        Task<int> someWater = ScoopingWater();

        yield return someWater;

        totle += await someWater;
    }
}

```

最终会每次随机舀水，花费随机时间，水全部舀完。

输出：

```csharp
这一瓢舀水量：4 2023/5/11 23:06:29
这一瓢舀水量：3 2023/5/11 23:06:30
这一瓢舀水量：2 2023/5/11 23:06:32
这一瓢舀水量：2 2023/5/11 23:06:34
这一瓢舀水量：3 2023/5/11 23:06:35
这一瓢舀水量：4 2023/5/11 23:06:36
这一瓢舀水量：2 2023/5/11 23:06:37
....
水全部舀完~     2023/5/11 23:07:27
```
通过上文例子，可以更深入理解 `yield` 创建的异步生成器。

## 总结

- 使用 `yield` 关键字可以将一个方法转换为一个返回可枚举对象或迭代器的方法，而不必手动实现 IEnumerable 和 IEnumerator 接口
- 使用 `yield` 来创建异步生成器，在某些场景下可以实现更高效、可靠的异步编程。

解读 --- yield 关键字

## 引言

**迭代器模式**是一种行为型设计模式，它允许按照特定顺序遍历集合对象的元素，同时不暴露集合的内部结构。这样做可以让客户端代码不依赖于集合对象的具体实现，从而提高代码的灵活性和可重用性。



在迭代器模式中，聚合对象将其遍历的职责委托给迭代器对象，而不是在聚合对象中实现遍历。

迭代器模式的优点是可以支持以不同的方式遍历一个聚合对象，而且可以隐藏遍历元素的内部细节。

在 C# 中，迭代器模式可以通过实现`IEnumerable`和`IEnumerator`接口来实现。其中 `IEnumerable`接口定义了一个`GetEnumerator`方法，返回一个实现了`IEnumerator`接口的迭代器对象。`IEnumerator`接口则定义了访问集合中元素的方法，包括`Current`、`MoveNext`和`Reset`等。

### 迭代器实现


```csharp
public class MyCollection : IEnumerable
{
    private int[] items = new int[5] { 31, 12, 3, 64, 51 };

    // 实现 IEnumerable 接口，返回一个枚举器
    public IEnumerator GetEnumerator()
    {
        return new MyEnumerator(items);
    }

    // 自定义迭代器类
    private class MyEnumerator : IEnumerator
    {
        private int[] items;
        private int position = -1;

        public MyEnumerator(int[] items)
        {
            this.items = items;
        }

        public object Current
        {
            get
            {
                if (position >= 0 && position < items.Length)
                {
                    return items[position];
                }
                else
                {
                    throw new InvalidOperationException();
                }
            }
        }

        public bool MoveNext()
        {
            position++;
            return (position < items.Length);
        }

        public void Reset()
        {
            position = -1;
        }
    }
}
```
这样我们可以直接使用`foreach`进行遍历：

```csharp
MyCollection collection = new MyCollection();

foreach (int item in collection)
{
     Console.WriteLine(item);
}
```
输出结果

```csharp
31
12
3
64
51
```
## 结论
这就是迭代器模式的基本用法。它可以让我们轻松地遍历集合对象中的元素，而不必暴露集合的内部结构。此外，通过实现`IEnumerable`和`IEnumerator`接口，我们可以轻松地在 C# 中实现迭代器模式。


:::tip{title="提示"}
`foreach`是c#语法糖，用来遍历实现了`IEnumerable`接口的集合类。

`foreach `循环的原理是通过调用集合类的`GetEnumerator`方法，返回一个实现了`IEnumerator`接口的迭代器对象，然后通过迭代器对象的`MoveNext`方法，依次访问集合中的每个元素，直到集合中的所有元素都被访问完毕。
:::

重温设计模式 --- 迭代器模式

## 引言
**策略模式**是一种行为设计模式，它允许在运行时选择算法的行为。该模式定义了一系列算法，将它们封装成独立的类，并使它们可以互相替换。这使得算法可以独立于使用它们的客户端而变化。


在策略模式中，有三个主要的角色：

- **环境（Context）**：它是使用策略的对象，它维护一个对策略对象的引用，并将客户端请求委托给该对象执行。
- **抽象策略（Strategy）**：它定义了所有具体策略所遵循的接口，通常由一个抽象类或者接口实现。
- **具体策略（Concrete Strategy）**：它实现了抽象策略中定义的接口，提供了算法的具体实现。

接下里使用c#创建一个购物车，为产品计算不同的折扣：

### 抽象策略类

```csharp
// 抽象策略类
public abstract class DiscountStrategy
{
    public abstract decimal CalculateDiscount(decimal price);
}
```

### 具体策略类


```csharp
public class ChristmasDiscount : DiscountStrategy
{
    public override decimal CalculateDiscount(decimal price)
    {
        return price * 0.3m;
    }
}

public class SpringFestivalDiscount : DiscountStrategy
{
    public override decimal CalculateDiscount(decimal price)
    {
        return price * 0.5m;
    }
}
```

### 环境类


```csharp
public class ShoppingCart
{
    private DiscountStrategy discountStrategy;

    public ShoppingCart(DiscountStrategy discountStrategy)
    {
        this.discountStrategy = discountStrategy;
    }

    public decimal CalculateTotalPrice(decimal price)
    {
        return price - this.discountStrategy.CalculateDiscount(price);
    }
}
```
上文例子中，我们定义了一个抽象策略类`DiscountStrategy`，它定义了一个`CalculateDiscount`方法。然后我们定义了两个具体策略类`ChristmasDiscount`和 `SpringFestivalDiscount`，它们分别实现了`CalculateDiscount`方法以提供具体的折扣计算逻辑。


最后，我们定义了一个环境类`ShoppingCart`，它持有一个`DiscountStrategy`对象，并在计算购物车中物品的总价时，使用持有的`DiscountStrategy`对象来计算折扣。客户端可以在运行时选择不同的具体策略对象作为`DiscountStrategy`，以便在计算购物车物品总价时选择不同的折扣算法。

接下假设有一个Prada包的价格是12000，可以分别计算一下圣诞节折扣价和春节折扣价：
```csharp
decimal pradaBag = 12000;
DiscountStrategy christmasDiscount = new ChristmasDiscount();
DiscountStrategy springFestivalDiscount = new SpringFestivalDiscount();

ShoppingCart christmasShoppingCart = new ShoppingCart(christmasDiscount);
ShoppingCart springFestivalShoppingCart = new ShoppingCart(springFestivalDiscount);

var discountedPrice = christmasShoppingCart.CalculateTotalPrice(pradaBag);
Console.WriteLine("Prada bag christmas discount price is " + discountedPrice);

discountedPrice = springFestivalShoppingCart.CalculateTotalPrice(pradaBag);
Console.WriteLine("Prada bag  Spring Festival discount price is " + discountedPrice);

```
输出：

```csharp
Prada bag christmas discount price is 8400.0
Prada bag  Spring Festival discount price is 6000.0
```


## 结论
策略模式的核心是抽象策略类和具体策略类。抽象策略类定义了一个接口或抽象类，具体策略类实现了这个接口或抽象类，并实现了具体的算法或行为。在使用策略模式时，我们首先创建一个策略接口或抽象类，然后定义多个具体策略类实现这个接口或抽象类。

在程序运行时，我们可以动态地切换不同的具体策略类，从而实现不同的算法或行为。这种灵活性使得策略模式非常适合那些需要在运行时根据不同条件选择不同算法的场合。