设计模式——迭代器模式(Iterator)

[align=center]设计模式(18):迭代器模式(Iterator)[/align]

[align=center] [/align]

[align=center]迭代器模式(Iterator)[/align]

[align=center] [/align]

[align=left]定义[/align]

[align=left] 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。最长见的foreach in.[/align]

[align=left]动机[/align]

[align=left] 当你需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，或者你需要对聚集有多种方式遍历时，你就应该考虑用迭代器模式。迭代器模式为不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。[/align]

[align=center]迭代器模式(Iterator)结构图[/align]

[align=center] [/align]



[align=left]Iterator迭代器抽象类[/align]

abstract class Iterator

{

public abstract object First();

public abstract object Next();

public abstract bool IsDone();

public abstract object CurrentItem();

}

Aggregate聚集抽象类

abstract class Aggregate

{

public absrtact Iterator CreateIterator();

}

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.Count)

{

ret = aggregate[current];

}

return ret;

}

public override bool IsDone()

{

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

}

public override object CurrentItem()

{

return aggregate[current];

}

}

ConcreteAggregate具体聚集类 继承Aggregate

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.Count[index]; }

set { items.Insert(index,value)}

}

}

客户端代码

static void Main(string[] args)

{

ConcreteAggregate a=new ConcreteAggregate();

a[0]="mingming";

a[0]="lili";

iterator i=new ConcreteIterator(a);

object item=i.First();

while(!i.IsDone())

{

Console.WriteLine("{0}请买票！"，i.CurrentItem());

i.Next();

}

}

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