IteratorPattern

意图
提供一种方法顺序访问一个聚合对象中各个元素,而又不许暴露该对象的内部表示.
什么叫聚合对象--->就是类似与数组或集合的对象.
其实就是将一些对象放到一个聚合中,来一起组织它们,来遍历它,或者得到当前的某个元素.

 

适用性
1.访问一个聚合对象的内容而无须暴露它的内部表示.
聚合对象可能是数组或者集合,我们在迭代聚合对象的时候不需要知道它底层是用什么来表示的,也就是不需要知道用数组还是集合来表示的.不需要去关心它,我们只需要去迭代它,获得我想知道的元素.向使用者屏蔽了底层的一种实现机制.然后我们通过很简单的方法,把聚合对象里的内容得到.

 

2.支持对聚合对象的多种遍历.
从前往后遍历,从后往前遍历........

 

3.为遍历不同的聚合结构提供一个统一的接口(既,支持多态迭代)

 

构成
1.抽象迭代器(Iterator)角色:此抽象角色定义出遍历元素所需的接口.
比如:我要得到聚合对象第一个元素,得到最后一个元素,得到当前元素.当前元素的下一个元素提供了这些规范.

 

2.具体迭代器(ConcreteIterator)角色:此角色实现了Iterator接口,并保持迭代过程中游标的位置.
当我们去遍历或者迭代一个聚合对象的时候,我们必须要有一种机制去保证,我们当前迭代到什么位置上了,我们是否还有能力继续去迭代,也就是这个聚合对象是否已经遍历完了,我们需要一种这样的机制来控制,这种机制可以通过游标的方式来控制.游标就相当于一个数组的索引,或者是集合的下标.

 

3.聚集(Aggregate)角色:此抽象角色给出创建迭代器(Iterator)对象的接口迭代角色是对聚集迭代的,它们是有密切的关联的因此我们通过具体聚集角色去创建相应的具体迭代器角色.

 

4.具体聚集(ConcreteAggregate)角色:实现了创建迭代器(Iterator)对象的接口,维持了一组对象引用的一个聚集对象,返回一个合适的具体迭代器实例.
创建的具体迭代器角色就可以迭代相应的具体聚集角色,具体的迭代器角色一定要知道它是对谁来进行迭代的.具体的聚集角色和具体的迭代器角色是互相关联的一种关系,具体聚集角色创建具体迭代角色,然而具体迭代角色又知道对谁来进行迭代.

 

5.客户端(Client)角色:持有对聚集及其迭代子对象的引用,调用迭代子对象的迭代接口,也有可能通过迭代器操作聚集元素的增加和删除.
客户端角色可以创建聚集角色和相应的迭代器角色,然后通过迭代器角色去迭代相应的聚集角色.

 

ClassDiagram:

 

SequenceDiagrm:

 

 class Client
    {
        static void Main(string[] args)
        {
            ConcreteAggregate aggregate = new ConcreteAggregate();

            aggregate[0] = "Item A";
            aggregate[1] = "Item B";
            aggregate[2] = "Item C";
            aggregate[3] = "Item D";

            Iterator iterator = aggregate.CreateIterator();

            Console.WriteLine("First Element:" + iterator.First());

            Console.WriteLine("Next Element:" + iterator.Next());

            Console.WriteLine("Current Element" + iterator.CurrentItem());

            Console.WriteLine("---------------------------------------");

            while (iterator.HasNext())
            {
                Console.WriteLine(iterator.Next());
            }

            Console.ReadKey();
        }
    }

    /// <summary>
    /// 迭代器角色
    /// </summary>
    abstract class Iterator
    {
        public abstract Object First();
        public abstract Object Next();
        public abstract Object CurrentItem();
        public abstract bool HasNext();
    }

    ///<summary>
    /// 具体迭代器角色
    ///</summary>
    class ConcreteIterator : Iterator
    {
        private int current = 0;
        ConcreteAggregate aggregate;
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }

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

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

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

        public override bool HasNext()
        {
            return current != aggregate.Count;
        }

    }

    /// <summary>
    /// 聚集角色
    /// </summary>
    abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

    /// <summary>
    ///具体的聚集角色
    /// </summary>
    class ConcreteAggregate : Aggregate
    {
        private ArrayList list = new ArrayList();

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

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

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