迭代器模式(Iterator)
提供一种方法顺序访问一个聚合对象中各个元素,而又不暴露该对象的内部表示。
一.NET应用:
.NET框架的迭代器已经为你准备好了接口。去实现就好
买车票实例代码实现:
IEumerator支持对非泛型集合的简单迭代接口
public interface IEumerator
{
object Current
{
get; //获取集合中的当前元素
}
bool MoveNext() ;
//将枚举数转到下一个元素。返回值true表示成功。返回值false表示已经在末尾
void Reset();
//恢复初始化指向的位置,第一个元素之前
}
IEnumerable公开枚举数,支持在非泛型集合上的简单迭代
public interface IEnumerable
{
IEumerator GetEnumerator();
//返回一个循环访问集合的枚举数
}
客户端:
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 );
}
Console.Read();
这里用到的foreach in 在编译器中做了些什么工作?
IEnumerator<string> e=a.GetEnumerator();
while(e.MoveNext())
{
Console.WriteLine("{0}请买票",e.Current);
}
效果展示
迭代器分离了集合对象的遍历行为,抽象出一个迭代器类来负责。优点:不暴露集合内部,又可让外部访问
二.迭代器代码实现
代码实现
//迭代器抽象类
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 Iterator CreateIterator(); //创建迭代器
}
//ConcreteAggregate
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); } //声明一个索引器
}
}
//ConcreteIterator
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 bool IsDone()
{
return current >= aggregate.Count ? true : false;
}
public override object CurrentItem()
{
return aggregate[current]; //返回当前的聚集对象
}
}
//具体迭代方式2:由后向前
class ConcreteIteratorDesc:Iterator
{
private ConcreteAggregate aggregate; //定义一个聚集对象
private int current = 0;
public ConcreteIteratorDesc(ConcreteAggregate aggregate)
{
this.aggregate = aggregate; //初始化时将具体对象传入
current = aggregate.Count - 1;
}
public override object First()
{
return aggregate[aggregate.Count - 1];
}
public override object Next()
{
object ret = null;
current--;
if (current >=0)
{
ret = aggregate[current]; //得到聚集的下一对象
}
return ret;
}
public override object CurrentItem()
{
return aggregate[current];//判断是否遍历到结尾,到结尾返回true
}
public override bool IsDone()
{
return current < 0 ? true : false; //返回当前聚集对象
}
}
客户端代码
ConcreteAggregate a = new ConcreteAggregate(); //公交车,即聚集对象
a[0] = "大鸟";
a[1] = "小菜";
a[2] = "行李";
a[3] = "老外";
a[4] = "公交内部员工";
a[5] = "小偷";
//Iterator i = new ConcreteIterator(a); //正序
Iterator i = new ConcreteIteratorDesc(a); //反序
//售票员出场,看好了上车的人。
//具体的迭代器ConcreteIterator来实现抽象的Iterator。为了多种迭代方式
//即声明迭代器对象
object item = i.First(); //从第一个乘客开始
while (!i.IsDone ())
{
Console.WriteLine("{0}请买车票!",i.CurrentItem ()); //对面前乘客告知买票
i.Next(); //下一乘客
}
Console.Read();
迭代器模式在访问数组、集合、列表、数据库操作普遍应用。各种高级语言都对它进行了封装。