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 = 0; // 设置正向遍历游标的初始值  
            cursor2 = objects.Count - 1; // 设置逆向遍历游标的初始值 
        }

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

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

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

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

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