想走？ 可以！ 先买票 迭代器模式

20.1 乘车买票 不管你是谁

20.2 迭代器模式

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

一个聚集对象，不管这些对象是什么都需要遍历的时候，就应该考虑用迭代器模式，

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

20.3 迭代器实现

namespace 迭代器模式
{
    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();
        }
    }

    //Iterator迭代器抽象类，
    abstract class Iterator
    {
        public abstract object First();                       //用于定义，得到第一对象，得到下一对象，返回当前对象，判读是否遍历结束等抽象方法，统一接口，
        public abstract object Next();
        public abstract object CurrentItem();
        public abstract bool IsDone();
    }

    //具体迭代器类，
    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 object CurrentItem()                   //返回当前聚集对象，
        {
            return aggregate[current];
        }

        public override bool IsDone()                          //判读当前是否遍历结束，
        {
            return current >= aggregate.Count ? true : false;
        }
    }

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

    //具体聚集类，
    class ConcreteAggregate : Aggregate                        //声明List泛型变量，用于存放聚合对象，
    {
        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); }
        }
    }

}

20.4 .NET的迭代器实现

namespace 迭代器模式
{
    class Program
    {
        static void Main(string[] args)
        {
            IList<string> a = new List<string>();
            a.Add("大鸟");
            a.Add("小菜");
            a.Add("行李");
            a.Add("老外");
            a.Add("公交内部员工");
            a.Add("小偷");

            foreach (string item in a)
            {
                Console.WriteLine("{0} 请买车票!", item);
            }

            IEnumerator<string> e = a.GetEnumerator();

            while (e.MoveNext())
            {
                Console.WriteLine("{0} 请买车票!", e.Current);
            }
            Console.Read();
        }
    }
}

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明的访问集合内部的数据，迭代器模式在访问数组，集合，列表等数据时，尤其是数据库数组操作时，是非常普遍的应用，由于它太普遍了，所以各种高级语言都对它进行了封装，

20.5 迭代高手