迭代器——对象行为模式

意图

又叫做游标（Cursor）模式。提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

适用性

1. 访问一个聚合对象的内容而无需暴露它的内部表示；
2. 支持对聚合对象的多种遍历（从前到后，从后到前）；
3. 为遍历不同的聚合结构提供一个统一的接口，即支持多态迭代。

结构图

角色

Iterator：定义迭代器访问和遍历元素的接口；
ConcreteIterator：实现具体的迭代器；
Aggregate：定义的容器，创建相应迭代器对象的接口；
ConcreteAggregate：具体的容器实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

实现

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

namespace Iterator
{
    /*Iterator迭代器抽象类*/
    abstract  class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract object CurrentItem();
        public abstract bool IsDone();
    }
    /*Aggregate聚集抽象类*/
    abstract class Aggregate
    {
        public abstract Iterator createIterator();
    }

    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 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 Iterator {
    class Program {
        static void Main(string[] args)
        {
            ConcreteAggregate ca = new ConcreteAggregate();
            ca[0] = "大鸟";
            ca[1] = "小菜";
            ca[2] = "行李";
            ca[3] = "老外";
            ca[4] = "公交内部员工";
            ca[5] = "小偷";

            Iterator i = new ConcreteIterator(ca);
            object obj = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine("{0} 请买车票！",i.CurrentItem());
                i.Next();
            }
            Console.Read();
        }
    }
}

总结

迭代器模式（Iterator）就是分离了聚合对象的遍历行为，抽象出一个迭代器来负责这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部数据。