设计模式--Iterator Pattern

• Iterator Pattern
  提供一个迭代器，用于访问不同数据类型的集合。访问一个聚合对象的内容而无须暴露它的内部表示。
  可以为聚合对象提供多种遍历方式； 可以为遍历不同的聚合结构提供一个统一的接口。
• 角色分析
• Iterator (迭代器)：定义访问和遍历集合的接口
• ConcreteIterator (具体迭代器)：实现迭代器接口方法，用于访问和遍历集合中的元素。
• Aggregate (抽象集合接口或类)：提供获取一个迭代器的接口
• ConcreteAggregate (集合类)：实现Aggregate中接口方法。
• 代码示例

/*
 *Iterator Pattern：主题就是使用迭代器，遍历集合中的每一项
 */
using System;
using System.Collections.Generic;
using System.Collections;


namespace Pattern01
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();

            a[0] = "Item A";
            a[1] = "Item B";
            a[2] = "Item C";
            a[3] = "Item D";

            //添加其他数据类型
            a[4] = 16;
            a[5] = false;

            // 创建一个迭代器

            Iterator i = a.CreateIterator();

            Console.WriteLine("Iterating over collection:");

            object item = i.First();
            while (item != null)
            {
                Console.WriteLine(item);
                item = i.Next();//
            }
            Console.ReadKey();
        }
    }
    /// <summary>
    /// Aggregate--抽象集合
    /// defines an interface for creating an Iterator object
    /// </summary>
    abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }
    /// <summary>
    /// ConcreteAggregate--具体集合。
    /// implements the Iterator creation interface to return an instance of the proper ConcreteIterator
    /// </summary>
    class ConcreteAggregate : Aggregate
    {
        private ArrayList _items = new ArrayList();//声明一个集合，用于保存数据项
        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); }
        }
    }
    /// <summary>
    /// Iterator --抽象迭代器
    /// defines an interface for accessing and traversing elements.
    /// </summary>
    abstract class Iterator
    {
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();


    }
    /// <summary>
    /// ConcreteIterator---具体迭代器，实现访问集合中的数据项
    /// implements the Iterator interface.
    /// keeps track of the current position in the traversal of the aggregate.
    /// </summary>
    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 - 1)
            {
                ret = _aggregate[++_current];
            }
            return ret;
        }
        public override object CurrentItem()
        {
            return _aggregate[_current];
        }
        public override bool IsDone()
        {
            return _current >= _aggregate.Count;
        }
    }
   

}

• 类图
  
• 代码示例2

/*
 * Iterator Pattern
 */
using System;
using System.Collections;

namespace Pattern02
{
    class Program
    {

        static void Main(string[] args)
        {

            Collection collection = new Collection();

            collection[0] = new Item("one");
           
            collection[1] = new Item("Item 1");
            collection[2] = new Item("Item 2");
            collection[3] = new Item("Item 3");
            collection[4] = new Item("Item 4");
            collection[5] = new Item("Item 5");
            collection[6] = new Item("Item 6");
            collection[7] = new Item("Item 7");
            collection[8] = new Item("Item 8");


            Iterator iterator = collection.GetIterator();

            // step设置为2
            iterator.Step = 2;

            Console.WriteLine("Iterating over collection:");

            Item item = iterator.First();
            while (!iterator.IsDone)
            {
                Console.WriteLine(item.Name);
                item= iterator.Next();
            }

            Console.ReadLine();
        }

    }
    /// <summary>
    /// 数据项
    /// </summary>
    class Item
    {
        private string _name;
        public Item(string name)
        {
            this._name = name;
        }
        public string Name
        {
            get { return _name; }
        }
    }
    interface IAbstractCollection
    {
        Iterator GetIterator();
    }
    interface IAbstractIterator
    {
        Item First();
        Item Next();
        bool IsDone { get; }
        Item CurrentItem { get; }
    }
    /// <summary>
    /// ConcreteIterator :提供访问和遍历集合的方法
    /// </summary>
    class Iterator : IAbstractIterator
    {
        private Collection _collection;
        private int _current = 0;
        private int _step = 1;
        public Iterator(Collection collection)
        {
            this._collection = collection;
        }

        public bool IsDone => _current >= _collection.Count;

        public Item CurrentItem => _collection[_current] as Item;

        public Item First()
        {
            _current = 0;
            return _collection[_current] as Item;
        }

        public Item Next()
        {
            _current += _step;
            if (!IsDone)
                return _collection[_current] as Item;
            else
                return null;
        }

        public int Step
        {
            get { return _step; }
            set { _step = value; }
        }
    }
    /// <summary>
    /// ConcreteAggregate，返回一个遍历集合的Iterator
    /// </summary>
    class Collection : IAbstractCollection
    {
        private ArrayList _items = new ArrayList();
        public Iterator GetIterator()
        {
            return new Iterator(this);
        }
        public int Count => _items.Count;
        public object this[int index]
        {
            get { return _items[index]; }
            set { _items.Add(value); }
        }
    }

}

• 总结
  １.声明一个Iterator接口，此接口至少包含Next() 用于访问集合中一下元素。为了操作方便，可以记录遍历集合的当前位置index，以及index是否已到集合的末尾。
  2.声明一个Aggregate接口，此接口提供一个迭代器方法。

3. 定义ConcreteIterator类实现Iterator接口方法。并通过构造函数为其绑定一个集合对象。
4. 定义具体集合类实现Aggregate接口方法，这个类的对象可作为参数传入ConcreteIterator构造函数，与其建立联系。
5. client 使用iterator提供的方法遍历集合中的元素。