模式的定义与特点

迭代器模式（iterator Pattern），为的提是可以顺序访问一个聚集中的元素而不必暴露聚集的内部表象。多个对象聚在一起形成的总体称之为聚集，聚集对象是能够包容一组对象的容器对象。迭代子模式将迭代逻辑封装到一个独立的子对象中，从而与聚集本身隔开。迭代模式简化了聚集的界面。每一个聚集对象都可以有一个或一个以上的迭代子对象，每一个迭代子的迭代状态可以是彼此独立的。迭代算法可以独立于聚集角色变化。

模式的优点

它支持以不同的方式遍历一个聚合对象。

迭代器简化了聚合类。

在同一个聚合上可以有多个遍历。

在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。

模式的缺点

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

using DesignPattern.ChainofResponsibilityPattern;
using DesignPattern.IteratorPatttern;
using DesignPattern.MementoPattern;
using DesignPattern.ObserverPattern;
using DesignPattern.VisitorPattern;
using System;
using System.Collections.Generic;

namespace DesignPattern
{
    internal class Program
    {
        static void Main(string[] args)
        {
            IteratorHelper();
        }

        #region Pattern - Iterator
        static void IteratorHelper()
        {
            ObjectRepository<string> _stringRepository = new ObjectRepository<string>();
            _stringRepository.AddObject("A");
            _stringRepository.AddObject("B");
            _stringRepository.AddObject("C");
            _stringRepository.AddObject(11.ToString());

            ObjectRepository<int> _intRepository = new ObjectRepository<int>();
            _intRepository.AddObject(-1);
            _intRepository.AddObject(10);
            _intRepository.AddObject(20);
            _intRepository.AddObject(30);


            for (Iterator<string> _iterator = _stringRepository.GetIterator(); _iterator.HasNext();)
            {
                Console.WriteLine("Object is: " + _iterator.Next());
            }

            Console.WriteLine("===================================================================");

            for (Iterator<int> _iterator = _intRepository.GetIterator(); _iterator.HasNext();)
            {
                Console.WriteLine("Object is: " + _iterator.Next());
            }
            Console.ReadLine();
            #endregion
        }
    }
}

//=======================================================================================================

namespace DesignPattern.IteratorPatttern
{
    /// <summary>
    /// 迭代器
    /// </summary>
    public interface Iterator<T>
    {
        bool HasNext();
        T Next();
    }

    /// <summary>
    /// 容器集装箱
    /// </summary>
    public interface IContainer<T>
    {
        Iterator<T> GetIterator();
    }

    /// <summary>
    /// 对象库
    /// </summary>
    public class ObjectRepository<T> : IContainer<T>
    {
        ObjectIterator<T> m_ObjectIterator;

        public ObjectRepository()
        {
            m_ObjectIterator = new ObjectIterator<T>();
        }
        public Iterator<T> GetIterator()
        {
            return m_ObjectIterator;
        }

        public void AddObject(T obj)
        {
            m_ObjectIterator.m_ObjectRepository.Add(obj);
        }

        /// <summary>
        /// 对象迭代器
        /// </summary>
        class ObjectIterator<Tobjcet> : Iterator<Tobjcet>
        {
            public ObjectIterator()
            {
                m_ObjectRepository = new List<Tobjcet>();
            }

            int index;
            public List<Tobjcet> m_ObjectRepository;

            public bool HasNext()
            {
                if (index < m_ObjectRepository.Count)
                {
                    return true;
                }
                return false;
            }

            Tobjcet Iterator<Tobjcet>.Next()
            {
                if (HasNext())
                {
                    return m_ObjectRepository[index++];
                }
                return default;
            }
        }
    }
}