迭代器模式(Iterator Pattern)

        迭代器模式提供了一种顺序访问某个集合中各个元素的解决方案。迭代器模式的目的就是将遍历集合对象的行为抽象来，构成一个迭代器类，让它来完成遍历工作。我们将储存集合对象的数据结构称容器，迭代器的目的就是遍历容器。分离的目的在于为访问容器中的元素提供不同的迭代器，避免容器的数据结构过于复杂，这样的设计使得“迭代器”和“容器”都符合“单一职责原则”设计原则。
       迭代器模式的优点是简化了容器的接口，支持以不同的方式遍历一个容器角色，可以自己写深层遍历和多种遍历的迭代器。但是在迭代器遍历的过程中，通过该迭代器进行容器元素的增减操作是否安全是我们应该注意的问题。

       结构图:


示例代码如下:

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

namespace  IteratorPattern
... {
    public class EntityModel
    ...{
        private string _name;

        /**//// <summary>
        /// 名称
        /// </summary>
        public string Name
        ...{
            get ...{ return _name; }
            set ...{ _name = value; }
        }

        /**///// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name">名称</param>
        public EntityModel(string name)
        ...{
            this._name = name;
        }

        public override string ToString()
        ...{
            return _name;
        }
    }

    public interface ICollection
    ...{
        IIterator CreateIterator();
    }

    public class Collection : ICollection
    ...{
        private IList<EntityModel> entityModels = new List<EntityModel>();


        public IIterator CreateIterator()
        ...{
            return new Iterator(this);
        }

        public int Count
        ...{
            get ...{ return entityModels.Count; }
        }

        /**//// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index">索引</param>
        /// <returns></returns>
        public EntityModel this[int index]
        ...{
            get 
            ...{
                EntityModel entityModel = null;
                if (index >= 0 && index < Count)
                ...{
                    entityModel = entityModels[index];
                }
                return entityModel;
            }
            set
            ...{
                if (index >= 0 && index < Count)
                ...{
                    entityModels[index] = value;
                }
            }
        }

        /**//// <summary>
        /// 增加元素
        /// </summary>
        /// <param name="entityModel"></param>
        public void Add(EntityModel entityModel)
        ...{
            entityModels.Add(entityModel); 
        }

        /**//// <summary>
        /// 移除元素
        /// </summary>
        /// <param name="entityModel"></param>
        public void Remove(EntityModel entityModel)
        ...{
            if (entityModels.Contains(entityModel))
            ...{
                entityModels.Remove(entityModel);
            }
        }

        /**//// <summary>
        /// 移除元素
        /// </summary>
        /// <param name="index"></param>
        public void RemoveAt(int index)
        ...{
            if (index >= 0 && index < Count)
            ...{
                entityModels.RemoveAt(index);
            }
        }
    }
    

    /**//// <summary>
    /// 迭代器（Iterator）角色：负责定义访问和遍历容器中的元素方法
    /// </summary>
    public interface IIterator
    ...{
        /**//// <summary>
        /// 是否迭代结束
        /// </summary>
        /// <returns></returns>
        bool HasNext();

        /**//// <summary>
        /// 当前对象
        /// </summary>
        EntityModel CurrentItem ...{ get; }

        /**//// <summary>
        /// 移动到开头
        /// </summary>
        void First();

        /**//// <summary>
        /// 向下移动
        /// </summary>
        void Next();
    }

    public class Iterator : IIterator
    ...{ 
        private Collection collection;
        private int index;

        /**///// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="collection"></param>
        public Iterator(Collection collection)
        ...{
            this.collection = collection;
            index = 0;
        }

        /**//// <summary>
        /// 是否迭代结束
        /// </summary>
        /// <returns></returns>
        public bool HasNext()
        ...{
            bool has = false;
            if (index < collection.Count)
            ...{
                has = true;
            }
            return has;
        }

        /**//// <summary>
        /// 移动到开头
        /// </summary>
        public void First()
        ...{
            index = 0;
        }

       /**//// <summary>
        /// 向下移动
        /// </summary>
        public void Next()
        ...{
           if (index < collection.Count)
           ...{
               index++;
           }
        }

        /**//// <summary>
        ///  当前对象
        /// </summary>
        /// <returns></returns>
        public EntityModel CurrentItem
        ...{
            get ...{ return collection[index]; }
        }      

    }

    class Program
    ...{
        static void Main(string[] args)
        ...{
            IIterator iterator;
            Collection collection = new Collection();
            collection.Add(new EntityModel("测试数据一！"));
            collection.Add(new EntityModel("测试数据二！"));
            collection.Add(new EntityModel("测试数据三！"));

            iterator = collection.CreateIterator();
            while (iterator.HasNext())
            ...{
                Console.WriteLine(iterator.CurrentItem);
                iterator.Next();
            }
            Console.ReadLine();
        }
    }
}

[1] http://www.cnblogs.com/singlepine/archive/2005/10/30/265024.html
[2] http://www.cnblogs.com/Terrylee/archive/2006/09/16/Iterator_Pattern.html
[3] http://www.cnblogs.com/webabcd/archive/2007/05/17/750715.html