自定义枚举器的需求点

Question

在阅读帖子时，没有示例给出了一些分数：

要实现 IEnumerable / IEnumerable，你必须提供一个枚举器：

•如果类正在“包装”另一个集合，则返回被包装的集合的枚举数。

•通过使用 yield return 的迭代器。

•通过实例化您自己的 IEnumerator/IEnumerator 实现

（我的小脑袋把它解释为）

（第 1 点）

    If the class is "wrapping" another collection, by returning the
wrapped collection's enumerator.

这意味着..

class  StringCollections
{

 //A class is wrapping another collection
  string[]  names=new string {“Jon Skeet”,”Hamish Smith”,
                  ”Marc Gravell”,”Jrista”,”Joren”};

//by returning the wrapped collection’s enumerator

 public IEnumerator GetEnumerator( )
  {
      // What should I return here ?
       //like the following ?
        yield return names[0];
        yield return names[1];
        yield return names[2];
      ....

       (or)
        foreach(string str in names)
        {
            yield return str;
         }                  

  }

}

（第 2 点）

•Via an iterator using yield return.(This point was well explained 
 by Marc Gravell)

第 3 点

By instantiating your own IEnumerator/IEnumerator<T> implementation*

第 3 点在这里代表什么？，因为没有例子，我没有得到那个。 这是否意味着，我可以构建自定义枚举器..（对吗？）。我的问题是预构建枚举器/枚举器何时足够（作为初学者，我不应该盲目地确认这一点） 我为什么要照顾自定义的迭代？很好的例子将澄清我的疑问。

感谢您阅读这篇冗长的故事和友好的回应。

Answer 1

（第 1 点） 您可以将 GetEnumerator 的调用链接到其他集合枚举器：

public class PrimeNumbers : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        var primes = new List<int> { 2, 3, 5, 7, 11 };
        return primes.GetEnumerator();
    }
}

（第 2 点）类似于您代码中的示例

public IEnumerator GetEnumerator()
{
    var primes = new List<int> { 2, 3, 5, 7, 11 };
    foreach (var number in primes)
    {
        yield return number;
    }
}

或者用逻辑放置枚举器：

public class PrimeNumbers : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        for(int i=2; ;i++)
        {
            if(IsPrime(i))
            {
                yield return i;
            }
        }
    }
}

（第 3 点） 您想要实现自己的 Enumerator 的情况并不多，但例如您可以查找无限的值集，例如素数：

public class PrimeNumbers : IEnumerable
{
    public IEnumerator GetEnumerator()
    {
        return new MyEnumerator();
    }
}

public class MyEnumerator : IEnumerator
{
    private int lastPrimeNumber = 1;

    public bool MoveNext()
    {
        lastPrimeNumber = /* some logic that find the next prime */;
        return true; // There is always next prime
    }

    public void Reset()
    {
        lastPrimeNumber = 1;
    }

    public object Current
    {
        get { return lastPrimeNumber; }
    }
}

一个用法示例可以是：

public void PrintAllPrimes()
{
    var numbers = new PrimeNumbers();

    // This will never end but it'll print all primes until my PC crash
    foreach (var number in numbers)
    {
        Console.WriteLine(number);
    }
}

我能想到的优点和缺点：

• 第 1 点：这是枚举项目的最简单方法，但它需要 提前了解所有项目
• 第 2 点：当枚举中有一些逻辑时，它是可读的，它是 也懒所以没必要 计算一个项目，直到它实际上是 请求
• 第 3 点：重复使用最简单，但可读性较差（计算项目 在 MoveNext 但实际上从 当前财产）。

Answer 2

这是一个例子：（注意：这是简化的，不是线程安全的例子）

public class PersonCollection : IEnumerable
{
    private ArrayList alPers = new ArrayList();
    public IEnumerator GetEnumerator() { return new myTypeEnumerator(this); }
    public class myTypeEnumerator : IEnumerator
    {
        int nIndex;
        PersonCollection pers;
        private int count { get { return pers.alPers.Count; } }
        public myTypeEnumerator(PersonCollection myTypes) 
         { pers = myTypes; nIndex = -1; }
        public bool MoveNext() { return nIndex <= count && ++nIndex < count; }
        // MovePrev() not strictly required
        public bool MovePrev() { return (nIndex > -1 && --nIndex > 0 ); }
        public object Current { get { return (pers[nIndex]); } }
        public void Reset() { nIndex = -1; }
    }
}

编辑：修复下面@Joren 提出的与移动上一个索引值低于 -1 相关的问题。当框架作为 foreach 实现的一部分调用时，MoveNext() 不需要此修复，因为在这种情况下，如果 MoveNext() 返回 false，枚举器实例将终止。但是，如果客户端手动调用 MoveNext()，枚举器不会终止，所以它也需要修复。

还请注意：如何实现这个东西内部的细节取决于你，并且将取决于它如何在内部管理状态。例如，如果保存引用的内部“桶”是一个链表，而不是一个 ArrayList，那么 MoveNext() 可以通过将 Current 字段更改为指向旧当前的 nextItem 属性来实现......

Answer 3

你所说的 1 实际上是 2。

对于 1，它会更像

public IEnumerator GetEnumerator() {
    return names.GetEnumerator();
}

对于第 3 点，这意味着让 GetEnumerator 做一些真正的工作：为您定义的集合手动实现一个 Enumerator。

Answer 4

“如果该类正在“包装”另一个集合，则通过返回被包装的集合的枚举数”意味着：

class StringCollections{
    //A class is wrapping another collection
    string[] names=new string {“Jon Skeet”,”Hamish Smith”,
                                ”Marc Gravell”,”Jrista”,”Joren”};
    public IEnumerator GetEnumerator() { return names.GetEnumerator(); }
}