常用的循环遍历数据方法---迭代器模式

        咱们在C#项目开发过程中，经常使用foreach的方式来循环遍历某个聚合对象；可能已有很多人遗忘了它的工作原理；今天，我们从这里开始：实际上它是把已经聚集好的一个集合，我们不需要知道其实际的对象类型而循环读取数据；这个地方就用到了我们今天要讲的设计模式---迭代器模式；有兴趣的同学，可以下来了解一下IEumerator 和IEnumerable 接口。

      什么是迭代器设计模式？提供一种方法顺序访问聚合对象中的各个元素，并又不暴露其内部表示。  也就是说，我们需要访问一个聚合对象的数据时候、需要对聚合对象采用不同的遍历方式的时候，就应该考虑迭代器模式来处理。这样的话，这种迭代器应该具有公有的访问开始、下一个、目前对象的数据、存在多少个对象、是否访问完成等方法。目前，JAVA、C# 等高级开发语言中已经 将对聚合对象的方法封装在一起了；我们使用动手开发类似的迭代器代码较少。所以我们今天仅讲其原理，方便以后备用。

    


代码部分如下：

//抽象迭代器，声明其方法
abstract class Iterator
{
//这个地方为什么返回的是object对象呢，因为所有的类都是从Object类继续过来的
//还有这个返回类型为object 是根据聚合对象 是什么类型而决定的
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
}
//一个具体的迭代器(ConcreteIterator)
class ConcreteIterator:Iterator
{
//定义一个具体的聚合对象（这个具体对象必须有具体的类型）
private ConcreteAggregate aggregate;
private int current=0;
//创建迭代器的时候，需要传入聚集对象
public ConcreteIterator(ConcreteAggregate aggregate);
{
this.aggregate=aggregate;
}
public override void First()
{
return aggregate[0];
}
public override void 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 ConcreteAggregate: Aggregate
{
//使用泛型定义个集合
private List<object> items=new List<object>();
public override Iterator CreateIterator()
{
return new ConcreteAggregate(this);
}
public int Count
{
get{return items.Count;}
}
public object this[int index]
{
get{ return items[index];}
set{ items.Insert(index,value);}
}
}

 客户端代码如下：
//客户端代码
ConcreteAggregate a=new ConcreteAggregate();
a[0]="合同工";
a[1]="临时工";
a[1]="公务员";
Iterator t=new ConcreteIterator(a);
object item=t.First();
while(!t.IsDone())
{
Console.WriteLine("{0}发工资",t.CurrentItem());
//读取下一个对象
t.Next

       如果咱咱们需要按照从后往前进行遍历，则只需重新冲Iterator类继承并重写里面的方法就OK了；是不是很简单。