## 引言

**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
```


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

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

重温设计模式 --- 策略模式

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



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

### 抽象享元

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