迭代器

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

先来说下什么是迭代器

1 IList<string> arr = new List<string>();

2 arr.Add("smith");

3 arr.Add("sherry");

4 arr.Add("steve");

5 arr.Add("salt");

6 arr.Add("stefan");

7 IEnumerator<string> emutor = arr.GetEnumerator();

8 while (emutor.MoveNext())

9     Console.WriteLine(emutor.Current);

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

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

1 foreach (string item in arr)

2     Console.WriteLine(item);

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

 1 IL_0045:  callvirt   instance class [mscorlib]System.Collections.Generic.IEnumerator`1<!0> class [mscorlib]System.Collections.Generic.IEnumerable`1<string>::GetEnumerator()

 2   IL_004a:  stloc.2

 3   .try

 4   {

 5     IL_004b:  br.s       IL_005b

 6     IL_004d:  ldloc.2

 7     IL_004e:  callvirt   instance !0 class [mscorlib]System.Collections.Generic.IEnumerator`1<string>::get_Current()

 8     IL_0053:  stloc.1

 9     IL_0054:  ldloc.1

10     IL_0055:  call       void [mscorlib]System.Console::WriteLine(string)

11     IL_005a:  nop

12     IL_005b:  ldloc.2

13     IL_005c:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()

14     IL_0061:  stloc.3

15     IL_0062:  ldloc.3

16     IL_0063:  brtrue.s   IL_004d

17     IL_0065:  leave.s    IL_0077

18   }  // end .try

19   finally

20   {

21     IL_0067:  ldloc.2

22     IL_0068:  ldnull

23     IL_0069:  ceq

24     IL_006b:  stloc.3

25     IL_006c:  ldloc.3

26     IL_006d:  brtrue.s   IL_0076

27     IL_006f:  ldloc.2

28     IL_0070:  callvirt   instance void [mscorlib]System.IDisposable::Dispose()

29     IL_0075:  nop

30     IL_0076:  endfinally

31   }  // end handler

View Code

跟foreach的关系

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

1 string[] arr = new string[] { "smith", "sherry", "Steve", "salt", "stefan" };

2 foreach (string item in arr)

3     Console.WriteLine(item);

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

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

1 string[] arr = new string[] { "smith", "sherry", "Steve", "salt", "stefan" };

2 IEnumerator emutor = arr.GetEnumerator();

3 while (emutor.MoveNext())

4     Console.WriteLine(emutor.Current);

使用il反编译的代码：

1 IL_0033:  callvirt   instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Array::GetEnumerator()

2   IL_0038:  stloc.1

3   IL_0039:  br.s       IL_0047

4   IL_003b:  ldloc.1

5   IL_003c:  callvirt   instance object [mscorlib]System.Collections.IEnumerator::get_Current()

6   IL_0041:  call       void [mscorlib]System.Console::WriteLine(object)

7   IL_0046:  nop

8   IL_0047:  ldloc.1

9   IL_0048:  callvirt   instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()

View Code

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

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

 1 public class Student

 2 {

 3     public string name { get; set; }

 4     public int score { get; set; }

 5     public Student(string firstName, int lastName)

 6     {

 7         this.name = firstName;

 8         this.score = lastName;

 9     }

10 }

11 //实现ienumerable接口的可枚举类型

12 

13 public class Students : IEnumerable

14 {

15     private Student[] arr;

16     public Students(Student[] peoples)

17     {

18         arr = new Student[peoples.Length];

19         for (int i = 0; i < peoples.Length; i++)

20         {

21             arr[i] = peoples[i];

22         }

23     }

24     public IEnumerator GetEnumerator()

25     {

26         return new StudentsEnum(arr);

27     }

28 }

然后你得实现他的枚举器

 1 //实现ienumerator接口的枚举函数 

 2 public class StudentsEnum : IEnumerator

 3 {

 4     private Student[] arr;

 5     //当前项的索引

 6     //这里是指针放到第一个集合成员之前

 7     //而非指向第一个集合成员

 8     private int i = -1;

 9     public StudentsEnum(Student[] peoples)

10     {

11         this.arr = peoples;

12     }

13     #region IEnumerator 成员

14     public object Current

15     {

16         get

17         {

18             try

19             {

20                 return arr[i];

21             }

22             catch (IndexOutOfRangeException)

23             {

24                 throw new IndexOutOfRangeException();

25             }

26         }

27     }

28     public bool MoveNext()

29     {

30         i++;

31         return i < arr.Length;

32     }

33 

34     public void Reset()

35     {

36         i = -1;

37     }

38     #endregion

39 }

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

1 Student[] peopleArray = new Student[3] { new Student("smith", 45), new Student("sherry", 56), new Student("salt", 67) };

2 Students people = new Students(peopleArray);

3 foreach (Student p in people)

4     Console.WriteLine("name:{0} \t score:{1}", p.name, p.score);

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

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

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

 1 public class City

 2 {

 3     #region IEnumerable 成员

 4     string[] m_Cities = { "New York", "Paris", "London" };

 5     public IEnumerator GetEnumerator()

 6     {

 7         Console.WriteLine(@"开始迭代~\(≧▽≦)/~啦啦啦");

 8         for (int i = 0; i < m_Cities.Length; i++)

 9             yield return m_Cities[i]; // 产生枚举元素

10     }

11     #endregion

12 }

还是一样的调用

1 City c = new City();

2 foreach (string item in c)

3     Console.WriteLine(item);

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

1 public string this[int n]

2 {

3     get { return m_Cities[n]; }

4     set { m_Cities[n] = value; }

5 }

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

好了收工