迭代器模式（Iterator Pattern），提供一种方法顺序访问一个聚合对象中元素，而不暴露改集合对象的内部表示。
Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation.
当需要访问一个聚集对象，而且不管这些对象是什么都需要遍历的时候，应该考虑用迭代器模式；当需要对聚集有多种方式遍历时，可以考虑使用迭代器模式。
Aggragate类：聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
ConcrateAggregate类：具体实现类，继承于Aggregate抽象类，实现创建迭代对象的方法。
Iterator迭代抽象类：定义一个接口用于访问和遍历集合中的各个元素；
First()方法：定位第一个元素
Next()方法：定位下一个元素
IsDone()方法：是否为结尾元素
CurrentItem()方法：定位当前对象
ConcreteIterator具体迭代类：继承于Iterator抽象类，实现父类中的各个方法。
1、聚集抽象类Aggregate及其具体实现类ConcreteAggregate
/// <summary>
/// The 'Aggregate' abstract class
/// </summary>
abstract class Aggregate
{
public abstract Iterator CreateIterator();
}
/// The 'ConcreteAggregate' class
class ConcreteAggregate : Aggregate
private ArrayList _items = new ArrayList();
public override Iterator CreateIterator()
{
return new ConcreteIterator(this);
}
// Gets item count
public int Count
get { return _items.Count; }
// Indexer
public object this[int index]
get { return _items[index]; }
set { _items.Insert(index, value); }
2、抽象迭代器类Iterator及其具体迭代器类ConcreteIterator
/// The 'Iterator' abstract class
abstract class Iterator
public abstract object First();
public abstract object Next();
public abstract bool IsDone();
public abstract object CurrentItem();
/// The 'ConcreteIterator' class
class ConcreteIterator : Iterator
private ConcreteAggregate _aggregate;
private int _current = 0;
// Constructor
public ConcreteIterator(ConcreteAggregate aggregate)
this._aggregate = aggregate;
// Gets first iteration item
public override object First()
return _aggregate[0];
// Gets next iteration item
public override object Next()
object ret = null;
if (_current < _aggregate.Count - 1)
{
ret = _aggregate[++_current];
}
return ret;
// Gets current iteration item
public override object CurrentItem()
return _aggregate[_current];
// Gets whether iterations are complete
public override bool IsDone()
return _current >= _aggregate.Count;
3、客户端代码
static void Main(string[] args)
ConcreteAggregate a = new ConcreteAggregate();
a[0] = "Item A";
a[1] = "Item B";
a[2] = "Item C";
a[3] = "Item D";
// Create Iterator and provide aggregate
ConcreteIterator i = new ConcreteIterator(a);
Console.WriteLine("Iterating over collection:");
object item = i.First();
while (item != null)
Console.WriteLine(item);
item = i.Next();
// Wait for user
Console.ReadKey();
遍历一个集合元素，在每次的遍历过程中跳过一些元素,如下图所示
IAbstractCollection类：聚集接口类 并通过CreateIterator()方法创建一个迭代对象。集合元素是Item类.
Collection类：具体实现类，继承于IAbstractCollection接口，实现创建迭代对象的方法。
IAbsctractIterator迭代接口类：定义一个接口用于访问和遍历集合中的各个元素；
Iterator具体迭代类：继承于IAbsctractIterator抽象类，实现父类中的各个方法。
1、聚集接口IAbstractCollection及其实现类Collection
/// A collection item
class Item
private string _name;
public Item(string name)
this._name = name;
// Gets name
public string Name
get { return _name; }
/// The 'Aggregate' interface
interface IAbstractCollection
Iterator CreateIterator();
class Collection : IAbstractCollection
public Iterator CreateIterator()
return new Iterator(this);
set { _items.Add(value); }
2、迭代器接口IAbstractIterator及其实现类Iterator
/// The 'Iterator' interface
interface IAbstractIterator
Item First();
Item Next();
bool IsDone { get; }
Item CurrentItem { get; }
class Iterator : IAbstractIterator
private Collection _collection;
private int _step = 1;
public Iterator(Collection collection)
this._collection = collection;
// Gets first item
public Item First()
_current = 0;
return _collection[_current] as Item;
// Gets next item
public Item Next()
_current += _step;
if (!IsDone)
return _collection[_current] as Item;
else
return null;
// Gets or sets stepsize
public int Step
get { return _step; }
set { _step = value; }
// Gets current iterator item
public Item CurrentItem
get { return _collection[_current] as Item; }
// Gets whether iteration is complete
public bool IsDone
get { return _current >= _collection.Count; }
// Build a collection
Collection collection = new Collection();
collection[0] = new Item("Item 0");
collection[1] = new Item("Item 1");
collection[2] = new Item("Item 2");
collection[3] = new Item("Item 3");
collection[4] = new Item("Item 4");
collection[5] = new Item("Item 5");
collection[6] = new Item("Item 6");
collection[7] = new Item("Item 7");
collection[8] = new Item("Item 8");
// Create iterator
Iterator iterator = new Iterator(collection);
// Skip every other item
iterator.Step = 2;
for (Item item = iterator.First();
!iterator.IsDone; item = iterator.Next())
Console.WriteLine(item.Name);
迭代器模式（Iterator Pattern），提供一种方法顺序访问一个聚合对象中元素，而不暴露改集合对象的内部表示。迭代器模式就是分离了集合对想的遍历行为，抽象出一个迭代器类来负责，这样即可以不暴露集合的内部机构，又可让外部代码透明地访问集合内部的数据
源代码参考：http://www.dofactory.com/Patterns/PatternIterator.aspx
版权
作者：灵动生活 郝宪玮
如果你认为此文章有用，请点击底端的【推荐】让其他人也了解此文章，
本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利。