迭代器模式（Iterator）

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

当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，就可以考虑使用迭代器模式。

迭代器为遍历不同的聚集结构提供如：开始、下一个、是否结束、当前哪一项等统一的接口。

此外，可以知悉，基本上所有的高级语言都封装了迭代器的实现，直接将此模式做在了语言当中。

如：Foreach in（C#），IEnumerable接口等

为什么将迭代器抽象成接口？

迭代方式的不同，可以使用不同的迭代器进行迭代

比如说我想要实现从后往前迭代——就可以通过实现迭代器接口实现

这样允许对聚集有多种方式遍历——可以考虑使用迭代器模式。

迭代器模式结构图

迭代器模式成员分析

聚集Aggregatee，

迭代器Iterator,

迭代器代码结构

代码实现:

    /// <summary>
    /// 抽象迭代器类
    /// </summary>
    abstract class Iterator
    {
        public abstract object First();//开始的对象
        public abstract object Next();//得到下一个对象
        public abstract bool IsDone();//是否到达尾部，遍历完成
        public abstract object CurItem();//当前对象

    }

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

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

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

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

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

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

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

    /// <summary>
    /// 具体聚集类
    /// </summary>
    class ConcreteAggregate : Aggregate
    {
        private IList<Object> items = new List<object>();

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

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

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

//客户端代码
ConcreteAggregate a = new ConcreteAggregate();
a[0] = "迭代0";
a[1] = "迭代1";
a[2] = "迭代2";

Iterator i = new ConcreteIterator(a);
object item = i.First();
while (!i.IsDone())
{
    Console.WriteLine(i.CurItem());
    i.Next();
}

迭代器模式总结

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

• 迭代器模式在访问数组、集合、列表等数据时，尤其是数据库数据操作时，非常普遍且适用。

• 基本上高级语言都对迭代器进行了封装。