迭代器模式（Iterator Pattern）

迭代器模式（Iterator pattern），提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
别名
游标（Cursor）。
适用性
迭代器模式可用来：
1）访问一个聚合对象的内容而无需暴露它的内部表示。
2）支持对聚合对象的多种遍历。
3）为遍历不同的聚合结构提供一个统一的接口(即,支持多态迭代polymorphic iteration)。

结构

参与者
Iterator（迭代器）
——迭代器定义访问和遍历元素的接口。
ConcreteIterator（具体迭代器）
——具体迭代器实现迭代器接口。
——对该聚合遍历时跟踪当前位置。
Aggregate（聚合）
——聚合定义创建相应迭代器对象的接口。
ConcreteAggregate（具体聚合）
——具体聚合实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。
协作
ConcreteIterator 跟踪聚合中的当前对象，并能够计算出待遍历的后继对象。
实现
1）谁控制该迭代 一个基本的问题是决定由哪一方来控制该迭代, 是迭代器还是使用该迭代器的客户。当由客户来控制迭代时, 该迭代器称为一个外部迭代器(external iterator)，而当由迭代器控制迭代时, 该迭代器称为一个内部迭代器(internal iterator)。使用外部迭代器的客户必须主动推进遍历的步伐，显式地向迭代器请求下一个元素。相反地,若使用内部迭代器，客户只需向其提交一个待执行的操作，而迭代器将对聚合中的每一个元素实施该操作。外部迭代器比内部迭代器更灵活；内部迭代器的使用较为容易，因为它们已经定义好了迭代逻辑。
2）谁定义遍历算法 迭代器不是唯一可定义遍历算法的地方。聚合本身也可以定义遍历算法，并在遍历过程中用迭代器来存储当前迭代的状态。我们称这种迭代器为一个游标(cursor),因为它仅用来指示当前位置。
3）迭代器健壮程度如何 在遍历一个聚合的同时更改这个聚合可能是危险的。
效果
迭代器模式分离了集合对象的遍历行为，抽象成一个迭代器类负责，这样既可以做到不暴露集合的内部 结构，又可以让外部代码透明地访问集合内部的数据。

参考代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyIterator
{
    abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

    class ConcreteAggregate : Aggregate
    {
        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[int index]
        {
            get { return items[index]; }
            set { items.Insert(index, value); }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyIterator
{
    abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }

    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;

            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];
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MyIterator
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();
            a[0] = "singleton";
            a[1] = "Factory Method";
            a[2] = "Abstract Factory";
            a[3] = "Builder";
            a[4] = "Prototype";

            Iterator i = new ConcreteIterator(a);
            Console.WriteLine("Creational pattern:");   
            for (object item = i.First(); !i.IsDone(); i.Next())
            {
                Console.WriteLine("{0}", i.CurrentItem());              
            }

            IList<string> l = new List<string>();
            l.Add("singleton");
            l.Add("Factory Method");
            l.Add("Abstract Factory");
            l.Add("Builder");
            l.Add("Prototype");
       
            Console.WriteLine("Creational pattern:");
            foreach (string item in l) // C#集成的迭代功能
            {
                Console.WriteLine("{0}", item);
            }

            // 同上面等价
            IEnumerator<string> e = l.GetEnumerator();
            while (e.MoveNext())
            {
                Console.WriteLine("{0}", e.Current);
            }

            Console.ReadKey();
         }
    }
}

相关模式

Composite：迭代器常被应用到象复合这样的递归结构上。
Factory Method：多态迭代器靠Factory Method来例化适当的迭代器子类。
Memento：常与迭代器模式一起使用。迭代器可使用一个memento来捕获一个迭代的状态。迭代器在其内部存储memento。

Factory Method结构

参考：《设计模式》、《大话设计模式》

学一门语言最好的时机是三年前，其次是现在。