迭代模式

傷城~ 2021-12-09 00:49 356阅读 0赞

## 前言 ##

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

**参考数据：**大话设计模式