CSharp设计模式读书笔记（17）：迭代器模式(学习难度：★★★☆☆，使用频率：★★★★★)

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。

模式角色与结构：

实现代码：

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

namespace CSharp.DesignPattern.IteratorPattern
{
    class Program
    {
        static void Main(string[] args)
        {
            List<Object> objects = new List<Object>();
            objects.Add("倚天剑");
            objects.Add("屠龙刀");
            objects.Add("断肠草");
            objects.Add("葵花宝典");
            objects.Add("四十二章经");  

            Aggregate list;
            Iterator iterator;  

            list = new ConcreteAggregate(objects); // 创建聚合对象
            iterator = list.CreateIterator();   // 创建迭代器对象  

            Console.WriteLine("正向遍历：");
            while(!iterator.IsLast()) {
                Console.WriteLine(iterator.GetNextItem() + "，");
                iterator.Next();
            }
            Console.WriteLine();
            Console.WriteLine("-----------------------------");
            Console.WriteLine("逆向遍历：");
            while(!iterator.IsFirst()) {
                Console.WriteLine(iterator.GetPreviousItem() + "，");
                iterator.Previous();
            }

            Console.ReadLine();
        }
    }

    // 抽象迭代器
    interface Iterator
    {
        void Next(); // 指向下一个元素
        void Previous(); // 移至上一个元素
        Boolean IsLast(); // 判断是否为最后一个元素
        Boolean IsFirst(); // 判断是否为第一个元素
        Object GetNextItem(); // 获取下一个元素
        Object GetPreviousItem(); // 获取上一个元素
    }

    // 具体迭代器
    class ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate; // 维持一个对具体聚合对象的引用，以便于访问存储在聚合对象中的数据
        private List<Object> objects;

        private int cursor1; // 定义一个游标，用于记录当前访问位置
        private int cursor2;

        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
            this.objects = aggregate.GetObjects(); // 获得集合对象

            cursor1 = ; // 设置正向遍历游标的初始值
            cursor2 = objects.Count - ; // 设置逆向遍历游标的初始值
        }

        public void Next()
        {
            if (cursor1 < objects.Count)
            {
                cursor1++;
            }
        }

        public void Previous()
        {
            if (cursor2 > -)
            {
                cursor2--;
            }
        }

        public Boolean IsLast()
        {
            return (cursor1 == objects.Count);
        }

        public Boolean IsFirst()
        {
            return (cursor2 == -);
        }

        public Object GetNextItem()
        {
            return objects[cursor1];
        }

        public Object GetPreviousItem()
        {
            return objects[cursor2];
        }
    }

    // 抽象聚合类
    abstract class Aggregate
    {
        protected List<Object> objects = new List<Object>();

        public Aggregate(List<Object> objects)
        {
            this.objects = objects;
        }  

        public void AddObject(Object obj) {
            this.objects.Add(obj);
        }  

        public void RemoveObject(Object obj) {
            this.objects.Remove(obj);
        }  

        public List<Object> GetObjects() {
            return this.objects;
        }

        // 声明创建迭代器对象的抽象工厂方法
        public abstract Iterator CreateIterator();
    }

    // 具体聚合类
    class ConcreteAggregate : Aggregate
    {
        public ConcreteAggregate(List<Object> objects)
            : base(objects)
        { }

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