.Net学习难点讨论系列11 foreach与迭代器，枚举数与可枚举值

本文主要整理于ASP.NET2.0开发指南部分内容、C#图解教程

要使一个自定义的集合类可以与foreach一起工作，我们需要实现IEnumerable接口（GetEnumerator方法）或实现IEnumerator<T>接口。

在.NET Framework枚举迭代相关类设计中IEnumerator是基础，其包含三个成员其中一个Current属性，两个函数Movenext与Reset。这些是一个集合对象可枚举的基础。而IEnumerable接口只包含一个GetEnumerator方法，作用就是返回一个IEnumerator对象。

.NET2.0新增的泛型接口IEnumerator<T>实现了IEnumerator与IDisposal接口，该接口自身包含一个Current属性，该属性返回一个T类型的对象。我们实现此接口时，需要实现其自身Current属性及父接口IEnumerator与IDisposal的方法。这其中特别需要注意的是，我们需要显式实现IEnumerator中的Current属性：

object System.Collections.IEnumerator.Current
{
    get { throw new NotImplementedException(); }
}

另一个泛型接口IEnumerable<T>继承自IEnumerable接口，其自身包含一个GetEnumerator方法返回泛型版本的IEnumerator<T>对象。类似于实现IEnumerator<T>，在实现IEnumerable<T>时，除了实现返回IEnumerator<T>的GetEnumerator方法，还要显示实现IEnumerable中的GetEnumerator方法：

System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
    throw new NotImplementedException();
}

了解了这些后就很容易解释迭代器(yield)了，迭代器提供给我们最简单的创建一个IEnumerator<T>对象或IEnumerable<T>的途径，见下面的代码段：

//返回泛型枚举数
public IEnumerator<string> SampleMethod1()
{
    yield return "tree";
    yield return "flower";
}

//返回泛型可枚举对象
public IEnumerable<string> SampleMethod2()
{
    yield return "tree";
    yield return "flower";
}

综合以上，下面看一个完整的例子：

public class Persons : IEnumerable
{
    public string[] m_Names;
    public Persons(params string[] Names)
    {
        m_Names = new string[Names.Length];
        Names.CopyTo(m_Names, 0);
    }

    //实现索引器
    public string this[int index]
    {
        get
        {
            return m_Names[index];
        }
        set
        {
            m_Names[index] = value;
        }
    }

    //实现IEnumerable成员
    //需返回一个IEnumerator类型的对象
    #region IEnumerable 成员

    IEnumerator IEnumerable.GetEnumerator()
    {
        return new PersonsEnumerator(this);
    }

    #endregion
}

public class PersonsEnumerator : IEnumerator
{
    int index = -1;
    Persons P;
    public PersonsEnumerator(Persons P)
    {
        this.P = P;
    }
    
    #region IEnumerator 成员

    object IEnumerator.Current
    {
        get
        {
            return P.m_Names[index];
        }
    }

    bool IEnumerator.MoveNext()
    {
        int tempIndex = ++index;
        if (tempIndex >= P.m_Names.Length)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    void IEnumerator.Reset()
    {
        index = -1;
    }
    #endregion
}

使用（非泛型）迭代器的方式：

static void Main()
{
    Persons arrPersons = new Persons("Michel", "Rebecca", "Polaris");
    foreach (string s in arrPersons)
    {
        Console.WriteLine(s);
    }
}

在C# 2.0中我们可以通过新增的关键字 – yeild，来方便的实现一个迭代器。而且.NET2.0中新增的泛型可以使迭代器强类型化。

一步步进行：首先我们将上述程序改写为用yield关键字实现（仍然是非泛型）。

public class Persons : IEnumerable
{
    public string[] m_Names;
    public Persons(params string[] Names)
    {
        m_Names = new string[Names.Length];
        Names.CopyTo(m_Names, 0);
    }

    #region IEnumerable 成员

    IEnumerator IEnumerable.GetEnumerator()
    {
        for (int i = 0; i < m_Names.Length; i++)
        {
            yield return m_Names[i];
        }
    }

    #endregion
}

接下来，我们将此方法改写为泛型的实现：

public class Persons<T> : IEnumerable<T>
{
    public T[] m_Names;
    public Persons(params T[] Names)
    {
        m_Names = new T[Names.Length];
        Names.CopyTo(m_Names, 0);
    }

    #region IEnumerable<T> 成员

    IEnumerator<T> IEnumerable<T>.GetEnumerator()
    {
        for (int i = 0; i < m_Names.Length; i++)
        {
            yield return m_Names[i];
        }
    }

    #endregion
}

泛型版迭代器的使用：

static void Main()
{
    Persons<string> arrPersons = new Persons<string>("Michel", "Rebecca", "Polaris");
    foreach (string s in arrPersons)
    {
        Console.WriteLine(s);
    }
}

上文基本列出了怎样使用yield实现一个迭代器。

下面来说一下yield的一些使用方式：

1. 终止yield迭代的方式

IEnumerator IEnumerable.GetEnumerator()
{
    for (int i = 0; i < m_Names.Length; i++)
    {
        yield return m_Names[i];
        if (i >= 1)
        {
            yield break;
        }
    }
}

2. 逆序迭代内容

IEnumerator IEnumerable.GetEnumerator()
{
    for (int i = (m_Names.Length - 1); i >= 0; --i)
    {
        yield return m_Names[i];
    }
}

3. 迭代器的另一种实现，返回实现IEnumerable<T>接口的对象，不实现GetEnumerator()方法。

public class Persons<T>
{
    private T[] m_Names;
    public Persons(params T[] Names)
    {
        m_Names = new T[Names.Length];
        Names.CopyTo(m_Names, 0);
    }

    public IEnumerable<T> GetPersons()
    {
        for (int i = 0; i < m_Names.Length; i++)
        {
            yield return m_Names[i];
        }
    }
}

class Program
{
    static void Main()
    {
        Persons<string> arrPersons = new Persons<string>("Michel", "Rebecca", "Polaris");
        foreach (string s in arrPersons.GetPersons())
        {
            Console.WriteLine(s);
        }
    }
}