什么时候应该创建从 IEnumerator/IEnumerable 派生的类？答案

【问题标题】：When should you create classes that are derived from IEnumerator/IEnumerable?什么时候应该创建从 IEnumerator/IEnumerable 派生的类？
【发布时间】：2020-06-26 11:54:00
【问题描述】：

我确实了解这两个接口（@987654321@ 和IEnumerable）的工作原理以及它们的用途。但是，我从来没有完全理解何时创建一个派生自这两个接口之一的类。据我所知，您可以在列表、数组和其他通用集合上执行foreach 循环，而无需像我在代码中那样创建类：

 class Program
{
   public static int[] array = new int[3] { 1, 2, 3 };
    static void Main(string[] args)
    {
        var Enumerable = new Aninfiniteenumerator();
        foreach(var i in infiniteEnumerable)
        {
            Console.WriteLine($"I is {i}");
        }
        Console.ReadKey();
    }
}
class Aninfiniteenumerator : IEnumerable<int> //Creating a class that is derived from IEnumerable
{  
    public IEnumerator GetEnumerator()
    {
        return new MyInfiniteEnumer(Program.array);
    }

    IEnumerator<int> IEnumerable<int>.GetEnumerator()
    {
        return new MyInfiniteEnumer(Program.array);
    }
}
public class MyInfiniteEnumer : IEnumerator<int> ////Creating a class that is derived from IEnumerator
{
    private int[] values;
    private int index = -1;
    public int Current => values[index];

    object IEnumerator.Current => Current;
    public MyInfiniteEnumer (int [] values)
    {
        this.values = values;
    }
    public void Dispose()
    {
    }

    public bool MoveNext()
    {
        index++;
        return index < values.Length;
    }

    public void Reset()
    {
        
    }
}

PS。我知道我的枚举器被称为“无限枚举器”，但它们不是无限的。因此，正如我所说，可以在通用列表/数组上执行 foreach 循环，而无需创建 IEnumerable/IEnumerator 类：

 class Program
{
    static void Main(string[] args)
    {
        Random rand = new Random();
        List<Car> vehicles = new List<Car>();
        for(int i = 0; i < 100; i++)
        {
            vehicles.Add(new Car(rand.Next(1970,2021), "Honda"));
        }
        foreach(var car in vehicles)
        {
            Console.WriteLine(car.yearProduced + ", " + car.model);
        }
        Console.ReadKey();
        for (int i = 0; i < 100; i++)
        {
            vehicles.Add(new Car(rand.Next(1970, 2021), "Subaru"));
        }
        foreach (var car in vehicles)
        {
            Console.WriteLine(car.yearProduced + ", " + car.model);
        }
        Console.WriteLine(vehicles.Count());
        Console.ReadKey();
    }
}
class Car
{
    public string model { get; set; }
    public int yearProduced { get; set; }
    public Car (int year, string model)
    {
        yearProduced = year;
        this.model = model;
    }
}

回到我的问题，我编写了第一个代码，以便能够对称为“Enumerable”的var 执行foreach 循环。我编写此代码只是为了练习，并没有看到创建从 IEnumerable 和 IEnumerator 派生的类的实际用途。那么，我的问题是，在哪些情况下您必须创建一个派生自这两个接口之一的类？

【问题讨论】：

IEnumerable（及其通用对应物）通常由是集合的类型实现。 IEnumerator（及其通用对应项）是一种用于执行实际“枚举”集合的机制。所以如果你的类型是一个集合，你应该实现 IEnumerable，如果你的类型有一个集合，你通常不会，而实现 IEnumerator 的类型通常是一个内部类型，如果你需要它在全部（也谷歌“c# yield return”）
我知道我的枚举数被称为“无限枚举数”，但它们不是无限的 那你为什么称它们为无限呢？ :)
Potomy chto before that moi code 是为了无限写 chisla

标签： c# generics iteration ienumerable

【解决方案1】：

可以使用枚举器的自定义结构的一个很好的例子是二叉树。

最简单的树是

public class Tree
{
   public Tree Left { get; set; }
   public Tree Right { get; set; }
   public object Value { get; set; }
}

这个定义可以用来组成任意树：

var root = new Tree()
{
   Left = new Tree() { Value = 1 },
   Right = new Tree() { Value = 2 },
   Value = 3
}

请注意，我的树是平衡的，但实际的树不必如此。

现在，您应该如何枚举所有值？这并不容易，在每个节点中你必须决定它是否有子节点，当你在节点处完成时，你必须回到它的父节点并探索所有路径。

但客户端代码对难不难不感兴趣，它期望代码是

 foreach ( var val in root )
 {
    // I want all values from the tree here!
 }

这是枚举的想法开始有意义的时候。它不仅仅是简单的线性结构，如数组或列表！

 public class Tree : IEnumerable
 {
     public IEnumerator GetEnumerator()
     {
         if ( Left != null ) foreach ( var e in Left ) yield return e;
         if ( Right != null ) foreach ( var e in Right ) yield return e;
         yield return Value;
     }
 }

我希望这个例子能对这个问题有所启发。

【讨论】：