C#迭代器模式探索：如何构建自定义迭代逻辑与IEnumerable_yield

# 1. C#迭代器模式基础

C#中的迭代器模式是提供一种简便的方式来遍历集合数据类型。它允许我们能够以连续的方式访问集合中的每一个元素，而不需要处理集合的内部结构。这种模式的关键优势在于，它使代码的编写更加简洁和易于维护。

## 1.1 迭代器的定义和作用

迭代器是一个方法或属性，可以提供一种方式来访问集合中的元素，而无需暴露集合的内部结构。它的主要作用是简化客户端代码，当客户端需要遍历集合时，不需要知道集合的具体实现细节。

## 1.2 迭代器的使用场景

迭代器广泛应用于各种场景，如遍历集合、逐行读取文件、实现分页功能等。在这些场景中，迭代器提供了一种高效和易于理解的方式来处理数据，使得代码更加清晰。

通过理解迭代器模式的基础概念，我们可以更好地掌握在C#中如何使用迭代器来实现需求，为接下来深入了解迭代器的高级特性和性能优化打下坚实的基础。

# 2. C#中自定义迭代逻辑的实现

在本章中，我们将深入探讨如何在C#中实现自定义的迭代逻辑。首先，我们将解释迭代器的工作原理，包括迭代器块以及如何使用yield关键字来创建迭代器。接着，我们将演示如何创建自定义集合类，其中包括实现IEnumerable接口和使用yield来实现自定义迭代逻辑。最后，我们将介绍迭代器的一些高级用法，比如如何组合多个迭代器，以及如何使用迭代器实现复杂的集合操作。

## 2.1 迭代器的工作原理

迭代器是C#中一种特殊的成员，它让我们能够逐项地遍历自定义集合类。在C#中，迭代器通过实现IEnumerable或IEnumerator接口，或是使用yield关键字定义的迭代器块来实现。

### 2.1.1 迭代器块和yield关键字

迭代器块允许开发者编写在调用方遍历集合时，逐个生成序列中下一个元素的代码。这使得我们可以编写更加直观和简洁的代码来实现自定义的序列操作。

public static IEnumerable<int> Range(int start, int count)
{
    for (int i = start; i < start + count; i++)
    {
        yield return i;
    }
}

在上面的例子中，`yield return`语句逐个返回序列中的下一个值。每调用一次，迭代器块会记住它在哪里执行，当下次调用时，它会从上次返回的地方继续执行。

### 2.1.2 迭代器返回类型和状态保持

迭代器可以返回IEnumerable<T>或IEnumerator<T>类型。返回IEnumerable<T>类型的迭代器会创建一个枚举器，而返回IEnumerator<T>类型的迭代器则直接返回枚举器本身。每调用一次`yield return`，迭代器都会保持其状态直到下一次调用。

public IEnumerator<int> GetEnumerator()
{
    return Range(1, 10).GetEnumerator();
}

上面的代码演示了一个返回类型为IEnumerable<int>的迭代器方法，它实际上返回了一个枚举器，该枚举器能够遍历1到10的整数序列。

## 2.2 创建自定义集合类

自定义集合类在C#中通常是实现IEnumerable接口，通过这个接口我们能够定义如何枚举集合中的元素。

### 2.2.1 实现IEnumerable接口

为了创建一个自定义的集合类，你需要实现IEnumerable接口，这通常意味着你需要同时实现GetEnumerator方法。

public class MyCollection : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator()
    {
        // 实现特定逻辑来枚举集合中的元素
        return new MyEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

public class MyEnumerator : IEnumerator<int>
{
    public int Current => 1; // 示例返回值

    object IEnumerator.Current => Current;

    public bool MoveNext()
    {
        // 实现移动到下一个元素的逻辑
        return true;
    }

    public void Reset()
    {
        // 实现重置枚举器状态的逻辑
    }

    public void Dispose()
    {
        // 实现资源清理逻辑（如果有的话）
    }
}

### 2.2.2 使用yield实现自定义迭代逻辑

使用yield关键字，我们可以用更简洁的方式实现IEnumerable接口，从而提供自定义的迭代逻辑。

public class CustomCollection : IEnumerable<int>
{
    public IEnumerator<int> GetEnumerator()
    {
        for (int i = 0; i < 10; i++)
        {
            yield return i;
        }
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

这段代码展示了一个自定义集合类，它利用yield返回了一个从0到9的整数序列。

## 2.3 迭代器的高级用法

迭代器的高级用法涉及到更复杂的序列操作，比如将多个迭代器组合成一个，或是创建支持延迟计算的集合。

### 2.3.1 组合多个迭代器

我们可以通过组合多个迭代器来创建更复杂的序列。例如，我们可以将多个自定义集合合并为一个，或者过滤、排序来自多个迭代器的元素。

### 2.3.2 使用迭代器实现复杂的集合操作

迭代器可以用于实现如分组、聚合、合并等多种复杂的集合操作。在下面的例子中，我们将展示如何使用迭代器来实现一个简单的分组操作。

public static IEnumerable<IGrouping<int, int>> GroupBy(this IEnumerable<int> source, Func<int, int> groupingFunction)
{
    Dictionary<int, List<int>> groups = new Dictionary<int, List<int>>();

    foreach (var item in source)
    {
        int key = groupingFunction(item);
        if (!groups.ContainsKey(key))
        {
            groups[key] = new List<int>();
        }
        groups[key].Add(item);
    }

    foreach (var group in groups)
    {
        yield return group;
    }
}

这段代码提供了一个通过迭代器实现的GroupBy方法，该方法可以对整数序列进行分组。

在下一章中，我们将探讨如何使用IEnumerable和yield关键字来遍历文件系统、实现异步迭代以及构建LINQ查询表达式，以充分发挥迭代器在实际应用中的强大功能。

# 3. IEnumerable与yield的应用实例

在本章节，我们将深入探讨`IEnumerable`和`yield`关键字的实际应用。通过具体的示例，我们将了解如何利用这些特性来简化代码和增强程序性能。我们将从遍历文件系统开始，进而探讨异步迭代的实现和LINQ查询表达式的构建。

## 3.1 遍历文件系统

遍历文件系统是编程中的常见任务，尤其是在处理文件或执行数据备份时。C#提供的`IEnumerable`和`yield`关键字可以非常方便地实现这一功能，同时保持代码的清晰性和效率。

### 3.1.1 使用yield递归遍历文件夹

递归遍历文件夹要求我们在访问一个目录时，能够递归地遍历它的所有子目录。下面是一个示例代码，展示了如何使用`yield`来递归地枚举一个目录下的所有文件。

using System;
using System.Collections.Generic;
using System.IO;

public class FileWalker
{
    public static IEnumerable<string> EnumerateFiles(string path, string searchPattern)
    {
        // 检查路径是否存在以及是否为目录
        if (Directory.Exists(path))
        {
            // 获取目录信息
            DirectoryInfo dirInfo = new DirectoryInfo(path);
            foreach (FileInfo file in dirInfo.GetFiles(searchPattern))
            {
                // 使用yield返回找到的文件信息
                yield return file.FullName;
            }
            // 遍历子目录
            foreach (DirectoryInfo subDir in dirInfo.GetDirectories())
            {
                // 递归调用以遍历每个子目录
                foreach (string file in EnumerateFiles(subDir.FullName, searchPattern))
                {
                    yield return file;
                }
            }
        }
    }
}

这个`EnumerateFiles`方法接受一个路径和搜索模式作为参数，并递归地遍历指定目录。每找到一个文件，它就使用`yield return`语句返回文件的完整路径。这种实现方式非常简洁，而且它将递归的复杂性隐藏在了一个简单的枚举器背后。

### 3.1.2 处理大量文件的分页枚举

在处理大量文件时，直接枚举可能会导致内存不足或程序反应迟钝。因此，实现分页枚举，也就是将文件分批次地枚举出来，会是更好的选择。以下是使用`yield`实现分页枚举的示例。

public static IEnumerable<IEnumerable<string>> EnumerateFilesInPages(string path, string searchPattern, int pageSize)
{
    var files = new Queue<string>(Directory.GetFiles(path, searchPattern));
    while (files.Count > 0)
    {
        var page = new List<string>();
        for (int i = 0; i <