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