迭代器模式(Iterator)

简介

迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。总地来说，迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样就可以做到不暴露集合的内部结构，又可让外部代码透明地访问集合内部的数据。

书中实例

小菜和大鸟在公交车上，只见售票员一个也不放过地向老外，公交公司员工，超重行李，包括小偷收票钱。大鸟说道:"这种遍历所有成员，也是一个设计模式的体现——迭代器模式"。

迭代器模式实现程序

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

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

    //具体迭代器类
    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 ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }

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

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

    }

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

    //具体迭代器类
    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 ret = null;
            current++;
            if (current < aggregate.Count)
            {
                ret = aggregate[current];
            }
            return ret;
        }

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

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

    }

    //具体聚集类
    class ConcreteAggregate : Aggregate
    {
        private IList<object> items = new List<object>();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }

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

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

    //客户端
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();

            a[0] = "大鸟";
            a[1] = "小菜";
            a[2] = "行李";
            a[3] = "老外";
            a[4] = "公交内部员工";
            a[5] = "小偷";

            Iterator i = new ConcreteIterator(a);
            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0} 请买车票！", i.CurrentItem());
                i.Next();
            }

            Console.Read();
        }
    }

组成类图

关系介绍

聚集抽象类(Aggregate)是具体聚集类的父类(ConcreteAggregate)。迭代抽象类(Iterator)是具体迭代器类(ConcreteIterator)的父类。聚集抽象类和迭代抽象类都和客户端是关联关系。具体迭代器类和具体聚集类之间有依赖关系和关联关系，具体聚集类依赖于具体迭代器类；具体迭代器类和具体聚集类有关。

迭代器模式的构成

Iterator(迭代器):迭代器定义访问和遍历元素的接口
ConcreteIterator(具体迭代器):具体迭代器实现迭代器接口，对该聚合遍历时跟踪当前位置
Aggregate(聚合):聚合定义创建相应迭代器对象的接口
ConcreteAggregate(具体聚合):具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例

迭代器模式的优点

1.它支持以不同的方式遍历一个聚合
2.迭代器简化了聚合的接口
3.在同一个聚合上可以有多个遍历

使用场景

1.当需要访问一个聚集对象，不管这些对象是什么都需要遍历时，应该考虑迭代器模式

2..当需要对聚集有多种方式遍历时，可以考虑用迭代器模式。