第15章 迭代器模式（Iterator Pattern）

原文 第15章 迭代器模式（Iterator Pattern）

迭代器模式（Iterator Pattern）

 

   概述：

 

        在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是归结起来，无非有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。

        提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。[GOF 《设计模式》]

 

   结构图：

 

    简单示例：可能中间对象引用的地方有点绕，但是写得很精髓

 /// <summary>
    /// 抽象迭代器
    /// </summary>
    public  interface  Iterator
    {
        object  GetCurrentItem(); //当前项
        bool  MoveNext(); //是否遍历完
        void  Next(); //下一个
    }
    /// <summary>
    /// 具体迭代器
    /// </summary>
    public  class  ConcreteTerator : Iterator
    {
        public  ConcreteList list;
        int  index = 0;
        public  ConcreteTerator(ConcreteList list)
        {
            this .list = list;
        }
        public  bool  MoveNext()
        {
            if  (index < list.Length)
            {
                return  true ;
            }
            else
            {
                return  false ;

            }
        }

        public  object  GetCurrentItem()
        {
           return  list.GetItem(index);
        }
        public  void  Next()
        {
            index++;
        }
    }

    /// <summary>
    /// 抽象聚集类
    /// </summary>
    public  interface  IList
    {
        //获取迭代器
        Iterator GetTerator();

    }
    /// <summary>
    /// 具体聚集类
    /// </summary>
    public  class  ConcreteList : IList
    {
        //这里就假设个Int数组对象
        public  int [] list
        {
            get ;
            set ;
        }
        public  int  Length
        {
            get
            {
                return  list.Length;
            }
        }
        public  object  GetItem( int  i)
        {
          return   list[i];
        }
        public  Iterator GetTerator()
        {
            //把本身传入到迭代器
            return  new  ConcreteTerator( this );
        }
    }

    //client
    class  Program
    {
        static  void  Main( string [] args)
        {
            ConcreteList list =  new  ConcreteList();
            list.list =  new  int [5] { 1, 2, 3, 4, 5 };
            Iterator terator = list.GetTerator();
            while  (terator.MoveNext())
            {
                Console.WriteLine(terator.GetCurrentItem());
                terator.Next();
            }
            Console.ReadLine();
        }
    }

 

     效果：

 

    1．迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

    2．迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。

    3．迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。

 

     适用场景：

 

 

    1．访问一个聚合对象的内容而无需暴露它的内部表示。

    2．支持对聚合对象的多种遍历。

    3．为遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

    

设计模式系列文章：http://www.diyibk.com/post/39.html