迭代器模式

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

下面举例实现：

首先定义抽象聚集类和具体聚集类

    /// <summary>
    /// 聚集抽象类
    /// </summary>
    abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

    /// <summary>
    /// 具体的聚集类，CreateIterator方法能够返回一个该类型对应的具体的迭代器
    /// </summary>
    class ConcreteAggregate : Aggregate
    {
        private List<object> item = new List<object>();

        public int Count
        {
            get { return item.Count; }
        }

        public object this[int index]
        {
            get { return item[index]; }
            set { item.Insert(index,value); }
        }

        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
    }

　　下面定义一个抽象迭代器类和具体迭代器类

    /// <summary>
    /// 迭代器抽象类
    /// </summary>
    abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object Current();
    }

    /// <summary>
    /// 针对某一个具体的聚集对象的具体的迭代器
    /// </summary>
    class ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate;
        private int current = 0;

        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }

        public override object First()
        {
            return aggregate[0];
        }

        public override object Next()
        {
            object next = null;
            if (current + 1 < aggregate.Count)
            {
                next = aggregate[++current];
            }
            return next;
        }

        public override bool IsDone()
        {
            return current+1 >= aggregate.Count ? true : false;
        }

        public override object Current()
        {
            return aggregate[current];
        }
    }

　客户端使用具体迭代器访问具体聚集类中的成员：

           ConcreteAggregate myAggregate = new ConcreteAggregate();
            myAggregate[0] = 0;
            myAggregate[1] = 1;
            myAggregate[2] = 2;

            ConcreteIterator iterator = (ConcreteIterator)myAggregate.CreateIterator();

            Console.WriteLine(iterator.First());
            while (!iterator.IsDone())
            {
                Console.WriteLine(iterator.Next());
            }

　执行结果如下：

0

1

2

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。另外，当你需要对聚集类有多种遍历方式时，也可以考虑用迭代器模式。

总体而言，迭代器模就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴漏集合的内部结构，又可以让外部代码透明的访问集合内部的数据。