设计模式（十六）迭代器模式

迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。迭代器模式为遍历不同的聚集结构提供如开始、下一个、是否结束、当前哪一项等统一的接口。

.NET 框架中 IEnumerator 支持对 非泛型集合 的简单迭代接口。

public interface IEnumerator
{
  object Current
  {
    get;   // 获取集合中的当前元素
  }
  // 将枚举数推进到集合的下一个元素。方法返回值 true 表示迭代器成功前进道集合中的下一个元素，返回值 false 表示已经位于集合的末尾
  bool MoveNext();

  // 恢复初始化指向的位置，该位置位于集合中第一个元素之前
  void Reset();
}

// 公开枚举数，该枚举数支持在非泛型集合上进行简单迭代
public interface IEnumerable
{
  // 返回一个循环访问集合的枚举数
  IEumerator GetEnumerator(); 
}

foreach(string item in a) 的内部实现

IEnumerator<string> e = a.GetEnumerator();

while(e.MoveNext())
{
  Console.WriteLine("{0}", e.Current);
}

 

 

 基本代码

// 迭代器抽象类，用于定义得到开始对象、下一个对象；判断是否到结尾、当前对象等抽象方法，统一接口
abstract class Iterator
{
  public abstract object First();
  public abstract object Next();
  public abstract bool IsDone();
  public abstract object CurrentItem();
}

// 聚集抽象类，创建迭代器
abstract class Aggregate
{
  public abstract Iterator CreateIterator();
}

// 具体聚集类
class ConcreteAggregate : Aggregate
{
  // 声明一个 IList 泛型变量，用于存放聚合对象，用 ArrayList 同样可以实现
  private IList<object> items = new List<object>();

  public override Iterator CreateIterator()
  {
    return new  ConcreteIterator(this);
  }

  // 返回聚集总个数
  public int Count
  {
    get { return items.Count; }
  }

  // 声明一个索引器
  public object this[this index]
  {
    get { return items[index]; }
    set { items.Insert(index, value); }
  }
}

// 具体迭代器类
class ConcreteIterator : Iterator
{
  // 定义一个具体聚集对象
  private ConcreteAggregate aggregate;
  private int current = 0;

  // 初始化时将具体的聚类对象传入
  public ConcreteIterator(ConcreteAggregate aggregate)
  {
    this.aggregate = aggregate;
  }

  // 得到聚集的第一个对象
  public override object First()
  {
    return aggregate[0];
  }

  // 得到聚集的下一个对象
  public override object Next()
  {
    object ret = null;
    current++;
    if(current < aggregate.Count)
    {
      ret = aggregate[current];
    }
    return ret;
  }

  // 判断当前是否遍历到结尾
  public override bool IsDone()
  {
    return current >= aggregate.Count ? true : false;
  }

  // 返回当前的聚集对象
  public override object CurrentItem()
  {
    return aggregate[current];
  }
}

// 实现从后向前反向遍历的具体迭代器类
class ConcreteIteratorDesc : Iterator
{
  // 定义一个具体聚集对象
  private ConcreteAggregate aggregate;
  private int current = 0;

  // 初始化时将具体的聚类对象传入
  public ConcreteIteratorDesc(ConcreteAggregate aggregate)
  {
    this.aggregate = aggregate;
    current = aggregate.Count -1;
  }

  // 得到聚集的第一个对象
  public override object First()
  {
    return aggregate[aggregate.Count -1];
  }

  // 得到聚集的下一个对象
  public override object Next()
  {
    object ret = null;
    current--;
    if(current >= 0)
    {
      ret = aggregate[current];
    }
    return ret;
  }

  // 判断当前是否遍历到结尾
  public override bool IsDone()
  {
    return current < 0 ? true : false;
  }

  // 返回当前的聚集对象
  public override object CurrentItem()
  {
    return aggregate[current];
  }
}

// 客户端
static void Main(string[] args)
{
  // 聚集对象
  ConcreteAggregate a = new ConcreteAggregate();
  a[0] = "1";
  a[1] = "2";
  a[2] = "3";

  // 声明迭代器对象
  Iterator i = new ConcreteIterator(a);
  //Iterator i = new ConcreteIteratorDesc(a);

  object item = i.First();
  while(!i.IsDone())
  {
    Console.WriteLine();
    i.Next();
  }

  Console.Read();
} 

【总结】

迭代器（Iterator）模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可以让外部代码透明地访问集合内部的数据。迭代器模式在访问数组、集合、列表等数据时，尤其是数据库操作时，是非常普遍的应用。