设计模式学习笔记十七——Iterator模式

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

场景：在.NET类库中，IEnumerable即为聚合对象接口，IEnumerator为迭代器接口，通过实现这两个接口来实现迭代器。

结构

代码

namespace DesignPattern.Iterator
{
    public class MyCollection : IEnumerable
    {
        int[] items;

        public MyCollection()
        {
            items = new int[5] {1, 2, 3, 4, 5};
        }

        public int[] Items
        {
            get
            {
                return items;
            }
        }

        public IEnumerator GetEnumerator()
        {
            return new MyEnumerator(this);
        }
    }

    public class MyEnumerator : IEnumerator
    {
        int index;
        MyCollection collection;

        public MyEnumerator(MyCollection collection)
        {
            this.collection = collection;
        }
        
        public object Current 
        {
            get
            {
                return collection.Items[index];
            }
        }
            
        public bool MoveNext()
        {
            index ++;
            return (index < collection.Items.GetLength(0));
        }
        
        public void Reset()
        {
            index = -1;
        }
    }
}

namespace DesignPattern.Iterator
{
    public class Client
    {
        public int Sum()
        {
            int sum = 0;

            MyCollection collection = new MyCollection();
            MyEnumerator iterator = new MyEnumerator(collection);

            while (iterator.MoveNext())
            {
                sum += Convert.ToInt32(iterator.Current);
            }

            return sum;
        }
    }
}

 要点：
      1、迭代抽象：本模式通过将对聚合对象的访问和遍历从聚合对象中分离出来并放入一个迭代器对象中，实现对聚合对象的透明访问。
      2、迭代多态：为遍历不同的聚合对象提供一个统一的接口，从而支持同样的算法在不同的聚合对象上进行操作。
      3、迭代器的健壮性考虑：遍历的同时更改迭代器所在的聚合结构，会导致问题。