迭代器的实现

1. using System;
2. using System.Collections.Generic;
3. using System.Linq;
4. using System.Text;
5. using System.Collections;
7. public class MyCollection : IEnumerable
8. {
9.     public int[] items;
10.     public MyCollection()
11.     {
12.         items = new int[5] { 12, 44, 33, 2, 50 };
13.     }
14.     //public IEnumerator GetEnumerator()
15.     //{
16.     //    return new MyEnumerator(this);
17.     //}
18.     //c#2.0后的实现方式
19.     public IEnumerator GetEnumerator()
20.     {
21.         for (int i = 0; i < items.Length; i++)
22.         {
23.             yield return items[i];
24.         }
25.     }
26. }
28. public class MyEnumerator : IEnumerator
29. {
30.     int nIndex;
31.     MyCollection collection;
32.     public MyEnumerator(MyCollection coll)
33.     {
34.         collection = coll;
35.         nIndex = -1;
36.     }
37.     public bool MoveNext()
38.     {
39.         nIndex++;
40.         return (nIndex < collection.items.GetLength(0));
41.     }
42.     public object Current
43.     {
44.         get
45.         {
46.             return (collection.items[nIndex]);
47.         }
48.     }
49.     public void Reset()
50.     {
51.         nIndex = -1;
52.     }
53. }
55. public class MainClass
56. {
57.     public static void Main()
58.     {
59.         MyCollection col = new MyCollection();
60.         foreach (int i in col)
61.         {
62.             Console.WriteLine(i);
63.         }
65.         Console.WriteLine("-----------------------");
67.         //完全抽象于(不依赖于)具休集合结构的访问操作
68.         IEnumerator ietor = col.GetEnumerator();
69.         while (ietor.MoveNext())
70.         {
71.             int i = (int)ietor.Current;
72.             Console.WriteLine(i);
73.         }
74.         Console.ReadKey();
75.     }
76. }

        在软件构建过程中，集合对象内部结构常常变化各  异。但对于这些集合对象，我们希望在不暴露其内 部结构的同时，可以让外部客户代码透明地访问其中包含的元素；同时这种“透明遍历”也为“同一种算 法在多种集合对象上进行操作”提供了可。

           使用面向对象技术将这种遍历机制抽象为“迭代器 对象”为“应对变化中的集合对象”提供了一种优雅的方式。

         

               意图:提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

Iterator模式的几个要点

  *  迭代抽象：访问一个聚合对象的内容而无 需暴露它的内部表示。

  *  迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

  *  迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。