迭代模式

前言

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

　　参考数据：大话设计模式