迭代器模式

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

   当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候， 你就需要考虑用迭代器模式。

   当你需要对聚集有多种方式遍历时， 可以考虑用迭代器模式。 为遍历不同的聚集结构提供如开始、下一个、是否结束、当前那一项等统一的接口。

 

Iterator迭代器抽象类：

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

Aggregate 聚集抽象类：

abstract class Aggregate{
           public abstract Itegator CreateIteretor();  //创建迭代器
           }

ConcreteIterator 具体迭代器类， 继承Iterator

           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.Conunt) {
           ret = aggregate[current];
           }
           return ret;

           }
            public override bool IsDone(){   //判断当前是否遍历到结尾，到结尾返回true

            return current >= aggregate.Count ? true :false;
            }

            public override object CurrentItem(){
            return aggregate[cirrent];  //返回当前的聚集对象
            }
           }

ConcreteAggregate 具体聚集类， 继承Aggregate

           class ConcreteAggregate : Aggregate{
           private IList<object> itmes = 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);}  //声明一个索引器
           }
           }

 客户端代码：

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();  //下一个乘客
	} 

	Concole.Read();
	}

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

 注：由于迭代器模式太普遍了， 所以各种高级语言都对它进行了封装，所以给人感觉此模式本身不太常用了