设计模式：迭代器模式（Iterator Pattern）

作者：TerryLee  创建于：2006-09-16 出处：http://www.cnblogs.com/Terrylee/archive/2006/09/16/Iterator_Pattern.html 收录于：2013-02-28

结构图

---

 

意图

---

提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

适用性

---

• 访问一个聚合对象的内容而无需暴露它的内部表示。
• 支持对聚合对象的多种遍历。
• 为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代）。

实现代码

---

在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是归结起来，无非有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。下面看一个简单的示意性例子，类结构图如下

using System;
class Program
{
    static void Main(string[] args)
    {
        IIterator iterator;
        IList list = new ConcreteList();
        iterator = list.GetIterator();
        while (iterator.MoveNext())
        {
            int i = (int)iterator.CurrentItem();
            Console.WriteLine(i.ToString());
            iterator.Next();
        }
        Console.Read();
    }
}
public interface IList
{
    IIterator GetIterator();
}
public interface IIterator
{
    bool MoveNext();
    Object CurrentItem();
    void First();
    void Next();
}
public class ConcreteList : IList
{
    int[] list;
    public ConcreteList()
    {
        list = new int[] { 1, 2, 3, 4, 5 };
    }
    public IIterator GetIterator()
    {
        return new ConcreteIterator(this);
    }
    public int Length
    {
        get { return list.Length; }
    }
    public int GetElement(int index)
    {
        return list[index];
    }
}
public class ConcreteIterator : IIterator
{
    private ConcreteList list;
    private int index;
    public ConcreteIterator(ConcreteList list)
    {
        this.list = list;
        index = 0;
    }
    public bool MoveNext()
    {
        if (index < list.Length)
            return true;
        else
            return false;
    }
    public Object CurrentItem()
    {
        return list.GetElement(index);
    }
    public void First()
    {
        index = 0;
    }
    public void Next()
    {
        if (index < list.Length)
        {
            index++;
        }
    }
}

 .NET中的Iterator模式

---

在.NET下实现Iterator模式，对于聚集接口和迭代器接口已经存在了，其中IEnumerator扮演的就是迭代器的角色NET中的Iterator模式

using System;
class Client 
{
    static void Main(string[] args)
    {
        Persons arrPersons = new Persons("Michel", "Christine", "Mathieu", "Julien");
        foreach (string s in arrPersons)
        {
            Console.WriteLine(s);
        }
        Console.ReadLine();
    } 
}
public interface IEumerator
{
    object Current
    {
        get;
    }
    bool MoveNext();
    void Reset();
}
public interface IEnumerable
{
    IEumerator GetEnumerator();
}
public class Persons : IEnumerable 
{ 
    public string[] m_Names; 
    public Persons(params string[] Names) 
    { 
        m_Names = new string[Names.Length]; 
        Names.CopyTo(m_Names,0); 
    } 
    
    public IEumerator GetEnumerator()
    {
        return new PersonsEnumerator(this);
    }
}

public class PersonsEnumerator : IEumerator
{
    private int index = -1;
    private Persons P;
    public PersonsEnumerator(Persons P)
    {
        this.P = P;
    }
    public bool MoveNext()
    {
        index++;
        return index < P.m_Names.Length;
    }
    public void Reset()
    {
        index = -1;
    }
    public object Current
    {
        get
        {
            return P.m_Names[index];
        }
    }
}

效果及实现要点

---

1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。