迭代模式

前言

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

一、Aggregate聚合抽象类

　　

    public abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

二、Iterator迭代器抽象类

　　

    public abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }

三、Iterator具体迭代类（正序迭代）

　　

  public 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 CurrentItem()
        {
            return aggregate[current];
        }

        //判断当前是否遍历到结尾
        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;
        }
    }

四、Iterator具体迭代类（倒序迭代）

　　

 public class ConcreteIteratorDesc : Iterator
    {
        //定义一个具体聚集对象
        private ConcreteAggregate aggregate;

        private int current = 0;
        //初始化时将具体的聚集对象传入
        public ConcreteIteratorDesc(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
            current = aggregate.Count - 1;
        }
        public override object CurrentItem()
        {
            return aggregate[current];
        }

        public override object First()
        {
            return aggregate[aggregate.Count - 1];
        }

        public override bool IsDone()
        {
            return current < 0 ? true : false;
        }

        public override object Next()
        {
            object ret = null;
            current--;
            if (current >= 0)
            {
                ret = aggregate[current];
            }
            return ret;
        }
    }

五、Aggregate具体的聚集类

    public 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); }
        }
    }

总结

　　1、当你需要对聚集有种方式遍历时，可以考虑用迭代模式。

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

　　参考数据：大话设计模式