Net设计模式实例之迭代器模式（Iterator Pattern）

一、迭代器模式简介（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