迭代器

都知道在c#2.0里有 迭代器，那么这个迭代器到底是个啥东东呢 他跟foreach又有啥关系

先来说下什么是迭代器

IList<string> arr = new List<string>();
arr.Add("smith");
arr.Add("sherry");
arr.Add("steve");
arr.Add("salt");
arr.Add("stefan");
IEnumerator<string> emutor = arr.GetEnumerator();
while (emutor.MoveNext())
    Console.WriteLine(emutor.Current);

这就是迭代器 他是专门针对集合元素的 ilist<string> 就是一个集合元素
ienumerator<string> 就是他的迭代器。可以通过moveNext()来枚举出他的所有子元素。

呐 我们来把while子句那一段换成这两句

foreach (string item in arr)
    Console.WriteLine(item);

用ildasm进行反编译可以看到他们的il代码是完全一样的

IL_0045:  callvirt   instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()
  IL_004a:  stloc.2
  .try
  {
    IL_004b:  br.s       IL_005b
    IL_004d:  ldloc.2
    IL_004e:  callvirt   instance !0 class [mscorlib]System.Collections.Generic.IEnumerator`1<string>::get_Current()
    IL_0053:  stloc.1
    IL_0054:  ldloc.1
    IL_0055:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_005a:  nop
    IL_005b:  ldloc.2
    IL_005c:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
    IL_0061:  stloc.3
    IL_0062:  ldloc.3
    IL_0063:  brtrue.s   IL_004d
    IL_0065:  leave.s    IL_0077
  }  // end .try
  finally
  {
    IL_0067:  ldloc.2
    IL_0068:  ldnull
    IL_0069:  ceq
    IL_006b:  stloc.3
    IL_006c:  ldloc.3
    IL_006d:  brtrue.s   IL_0076
    IL_006f:  ldloc.2
    IL_0070:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()
    IL_0075:  nop
    IL_0076:  endfinally
  }  // end handler

跟foreach的关系

foreach这个是原来就有的语法 就是让你的c#代码“更优雅”由编译器支持的 让你代替 for(int i,i<5,i++)这样的写法
诸如此类的例子在c#里还有很多
呐看下这段代码呢

string[] arr = new string[] { "smith", "sherry", "Steve", "salt", "stefan" };
foreach (string item in arr)
    Console.WriteLine(item);

注意啊 虽然都是foreach 但是此arr非彼arr 不存在迭代器的说法 ，这个是数组
通过ildasm反编译你就可以看到并没有类似::GetEnumerator()这样的代码存在

但是这种代码又不一样，因为显示使用了迭代器

string[] arr = new string[] { "smith", "sherry", "Steve", "salt", "stefan" };
IEnumerator emutor = arr.GetEnumerator();
while (emutor.MoveNext())
    Console.WriteLine(emutor.Current);

使用il反编译的代码：

IL_0033:  callvirt   instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator()
  IL_0038:  stloc.1
  IL_0039:  br.s       IL_0047
  IL_003b:  ldloc.1
  IL_003c:  callvirt   instance object [mscorlib]System.Collections.IEnumerator::get_Current()
  IL_0041:  call       void [mscorlib]System.Console::WriteLine(object)
  IL_0046:  nop
  IL_0047:  ldloc.1
  IL_0048:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()

怎样让你自己设计的集合类也应用迭代器呢

那么首先你得设计一个集合类 这个跟索引属性有点类似

public class Student
{
    public string name { get; set; }
    public int score { get; set; }
    public Student(string firstName, int lastName)
    {
        this.name = firstName;
        this.score = lastName;
    }
}
//实现ienumerable接口的可枚举类型

public class Students : IEnumerable
{
    private Student[] arr;
    public Students(Student[] peoples)
    {
        arr = new Student[peoples.Length];
        for (int i = 0; i < peoples.Length; i++)
        {
            arr[i] = peoples[i];
        }
    }
    public IEnumerator GetEnumerator()
    {
        return new StudentsEnum(arr);
    }
}

然后你得实现他的枚举器

//实现ienumerator接口的枚举函数 
public class StudentsEnum : IEnumerator
{
    private Student[] arr;
    //当前项的索引
    //这里是指针放到第一个集合成员之前
    //而非指向第一个集合成员
    private int i = -1;
    public StudentsEnum(Student[] peoples)
    {
        this.arr = peoples;
    }
    #region IEnumerator 成员
    public object Current
    {
        get
        {
            try
            {
                return arr[i];
            }
            catch (IndexOutOfRangeException)
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
    public bool MoveNext()
    {
        i++;
        return i < arr.Length;
    }

    public void Reset()
    {
        i = -1;
    }
    #endregion
}

实现了students集合的迭代器 那么我们接下来就可以使用它了

Student[] peopleArray = new Student[3] { new Student("smith", 45), new Student("sherry", 56), new Student("salt", 67) };
Students people = new Students(peopleArray);
foreach (Student p in people)
    Console.WriteLine("name:{0} 	 score:{1}", p.name, p.score);

综上所述 总之注意3个要素

1. 确定子元素
2. 为子元素设计集合类 并继承IEnumerable
   主要是增加这个方法就可以了
   public IEnumerator GetEnumerator()
       {
           return new StudentsEnum(arr);
       }
3. 实现集合类的枚举器
4. 使用集合时 调用GetEnumerator 获取枚举器 进行枚举，或者直接使用foreach子句

其实主要代码也就是枚举器的实现
我们有种偷懒的做法 ，那就是使用yield关键字

public class City
{
    #region IEnumerable 成员
    string[] m_Cities = { "New York", "Paris", "London" };
    public IEnumerator GetEnumerator()
    {
        Console.WriteLine(@"开始迭代~(≧▽≦)/~啦啦啦");
        for (int i = 0; i < m_Cities.Length; i++)
            yield return m_Cities[i]; // 产生枚举元素
    }
    #endregion
}

还是一样的调用

City c = new City();
foreach (string item in c)
    Console.WriteLine(item);

这都啥啊 我看着都晕了student类也没了 city的子元素是啥啊， 这不是索引器吗 像这样：

public string this[int n]
{
    get { return m_Cities[n]; }
    set { m_Cities[n] = value; }
}

你看都没有继承IEnumerable 还是可以同样的使用
是的GetEnumerator() 本意就是“获取一个索引器”
yield意思是 迭代 量产
而yield 搭配for语句使用 本意就是 “迭代出每一个元素”并“生成一个索引器”返回
说到这里相信你们理解到他的精髓了 迭代器 枚举器 索引器 其实他们指的是同一个东西 他们都针对集合使用

好了收工