十九.行为型设计模式——Iterator Pattern(迭代器模式)

• 定义

　　提供一种方法可以访问聚合对象，而不用暴露这个对象的内部表示。

　　UML类图如下：　　

　　

　　其中类和对象的关系为：

　　1.Iterator(迭代器)：迭代器定义访问和遍历元素的接口。

　　2.ConcreteIterator(具体迭代器)：实现迭代器的接口；在遍历时跟踪当前聚合对象中的位置。

　　3.Aggregate(聚合)：定义一个创建迭代器对象的接口。

　　4.ConcreteIterator(具体聚合)：实现创建迭代对象，返回一个具体迭代器的实例。

　　典型应用的顺序图如下：　　

　　

• 实例1——遍历例子：

　　下面的遍历例子延时了迭代器模式的应用。例子采用迭代来遍历集合中的子项目，定义了迭代步数，跳过特定编号的子项目。UML类图如下：　　

　　

　　

    //项目类
    class Item
    {
        string name;
        public Item(string name)
        {
            this.name = name;
        }
        public string Name
        {
            get { return name; }
        }
    }

    //Aggregate抽象聚合类
    abstract class AbstractCollection
    {
        abstract public Iterator CreateIterator();
    }

    //ConcreteAggregate具体聚合
    class Collection : AbstractCollection
    {
        private ArrayList items = new ArrayList();
        public override Iterator CreateIterator()
        {
            return new Iterator(this);
        }
        public int Count
        {
            get { return items.Count; }
        }
        //索引
        public object this[int index]
        {
            get { return items[index]; }
            set { items.Add(value); }
        }
    }

    //抽象迭代器Iterator
    abstract class AbstractIterator
    {
        abstract public Item First();
        abstract public Item Next();
        abstract public bool IsDone();
        abstract public Item CurrentItem();
    }

    //具体迭代器
    class Iterator : AbstractIterator
    {
        private Collection collection;
        private int current = 0;
        private int step = 1;
        public Iterator(Collection collection)
        {
            this.collection = collection;
        }
        //步长
        public int Step
        {
            get { return step; }
            set { step = value; }
        }
        //初始项目
        public override Item First()
        {
            current = 0;
            return (Item)collection[current];
        }
        //下一个
        public override Item Next()
        {
            current += step;
            if (!IsDone())
                return (Item)collection[current];
            return null;
        }
        //当前项目
        public override Item CurrentItem()
        {
            return (Item)collection[current];
        }
        //是不是到了最后
        public override bool IsDone()
        {
            return current >= collection.Count ? true : false;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Collection collection = new Collection();
            collection[0] = new Item("Item 0");
            collection[1] = new Item("Item 1");
            collection[2] = new Item("Item 2");
            collection[3] = new Item("Item 3");
            collection[4] = new Item("Item 4");
            collection[5] = new Item("Item 5");
            collection[6] = new Item("Item 6");
            collection[7] = new Item("Item 7");
            //生成迭代器
            Iterator iterator = new Iterator(collection);
            //步长为2，跳跃一个项目
            iterator.Step = 2;
            for (Item item = iterator.First(); !iterator.IsDone(); item = iterator.Next())
            {
                Console.WriteLine(item.Name);
            }
            Console.Read();
        }
    }

• 优势和缺陷：

　　迭代器模式支持在聚集中移动游标，使得访问聚合中的元素变得简单，简化了聚集的接口，封装了聚合的对象。

　　迭代器模式还可以应用于对树结构的访问，程序不需要从头逐行代码查找相应位置，可控制到从子集开始查找，对于加快程序的运行速度有很重要的作用。

　　迭代器模式的缺点是聚合密切相关，增加了耦合。但将这种耦合定义在抽象基类，可解决这个问题。

• 应用情景：

　　下面的情景很适合应用迭代器模式：

　　1.需要遍历访问聚集中的对象而不能暴露聚集的内部结构。

　　2.允许对聚集的多级遍历访问而不会相互受影响。

　　3.提供一个一致的接口来遍历聚集中不同的结构。