迭代模式
前言
迭代模式（Iterator），提供一种方法顺序访问一个聚合对象中各个元素，而不暴露该对象的内部表示。
一、Aggregate聚合抽象类
1 public abstract class Aggregate
2 {
3 public abstract Iterator CreateIterator();
4 }
二、Iterator迭代器抽象类
1 public abstract class Iterator
2 {
3 public abstract object First();
4 public abstract object Next();
5 public abstract bool IsDone();
6 public abstract object CurrentItem();
7 }
三、Iterator具体迭代类（正序迭代）
1 public class ConcreteIterator : Iterator
2 {
3 //定义一个具体聚集对象
4 private ConcreteAggregate aggregate;
5
6 private int current = 0;
7 //初始化时将具体的聚集对象传入
8 public ConcreteIterator(ConcreteAggregate aggregate)
9 {
10 this.aggregate = aggregate;
11 }
12 //得到聚集的第一个对象
13 public override object First()
14 {
15 return aggregate[0];
16 }
17 //返回当前聚集对象
18 public override object CurrentItem()
19 {
20 return aggregate[current];
21 }
22
23 //判断当前是否遍历到结尾
24 public override bool IsDone()
25 {
26 return current >= aggregate.Count ? true : false;
27 }
28 //得到聚集的下一个对象
29 public override object Next()
30 {
31 object ret = null;
32 current++;
33 if (current < aggregate.Count)
34 {
35 ret = aggregate[current];
36 }
37 return ret;
38 }
39 }
四、Iterator具体迭代类（倒序迭代）
1 public class ConcreteIteratorDesc : Iterator
2 {
3 //定义一个具体聚集对象
4 private ConcreteAggregate aggregate;
5
6 private int current = 0;
7 //初始化时将具体的聚集对象传入
8 public ConcreteIteratorDesc(ConcreteAggregate aggregate)
9 {
10 this.aggregate = aggregate;
11 current = aggregate.Count - 1;
12 }
13 public override object CurrentItem()
14 {
15 return aggregate[current];
16 }
17
18 public override object First()
19 {
20 return aggregate[aggregate.Count - 1];
21 }
22
23 public override bool IsDone()
24 {
25 return current < 0 ? true : false;
26 }
27
28 public override object Next()
29 {
30 object ret = null;
31 current--;
32 if (current >= 0)
33 {
34 ret = aggregate[current];
35 }
36 return ret;
37 }
38 }
五、Aggregate具体的聚集类
1 public class ConcreteAggregate : Aggregate
2 {
3 private IList<object> items = new List<object>();
4 public override Iterator CreateIterator()
5 {
6 return new ConcreteIterator(this);
7 }
8 //集合总数
9 public int Count { get { return items.Count; } }
10 //声明一个索引
11 public object this[int index]
12 {
13 get { return items[index]; }
14 set { items.Insert(index, value); }
15 }
16 }
总结
1、当你需要对聚集有种方式遍历时，可以考虑用迭代模式。
2、迭代器（Iterator）模式就是分离了集合对象的遍历行为，抽象出一个迭代器类负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。
参考数据：大话设计模式
