迭代器模式把对象的职责分离，职责分离可以最大限度减少彼此之间的耦合程度，从而建立一个松耦合的对象。职责分离的要点是对被分离的职责进行封装，并以抽象的方式建立彼此之间的关系。

1、迭代器模式简介

1.1>、定义

　　迭代器模式提供一种方法可以顺序访问聚合对象中各个元素，但又不暴露该对象的内部表示。

1.2>、使用频率

　　 高

2、迭代器模式结构

2.1>、结构图

2.2>、参与者

　　迭代器模式参与者：

　　◊ Iterator：迭代器定义访问和遍历元素的接口

　　◊ ConcreteIterator

　　　　° 具体迭代器实现迭代器接口

　　　　° 对该聚合遍历时跟踪当前位置

　　◊ Aggregate：聚合定义创建Iterator对象的接口

　　◊ ConcreteAggregate：具体聚合，实现相应迭代器的接口，返回具体迭代器的一个适当的实例。

　　在迭代器模式中，ConcreteAggregate通过Aggregate定义的接口得到Iterator，并且这是一个ConcreteIterator，该ConcreteIterator具体实现了对ConcreteAggregate的访问与遍历的方法。通过ConcreteIterator可以访问并使用集合中的元素。

3、迭代器模式结构实现

　　Iterator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Structural
  7. {
  8.     public abstract class Iterator
  9.     {
  10.         public abstract object First();
  11.         public abstract object Next();
  12.         public abstract bool IsDone();
  13.         public abstract object CurrentItem();
  14.     }
  15. }

　　Aggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Structural
  7. {
  8.     public abstract class Aggregate
  9.     {
  10.         public abstract Iterator CreateIterator();
  11.     }
  12. }

　　ConcreteAggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. using System.Collections;
  7.  
  8. namespace DesignPatterns.IteratorPattern.Structural
  9. {
  10.     public class ConcreteAggregate : Aggregate
  11.     {
  12.         private ArrayList _items = new ArrayList();
  13.  
  14.         public override Iterator CreateIterator()
  15.         {
  16.             return new ConcreteIterator(this);
  17.         }
  18.  
  19.         public int Count
  20.         {
  21.             get { return _items.Count; }
  22.         }
  23.  
  24.         public object this[int index]
  25.         {
  26.             get { return _items[index]; }
  27.             set { _items.Insert(index, value); }
  28.         }
  29.     }
  30. }

　　ConcreteIterator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Structural
  7. {
  8.     public class ConcreteIterator : Iterator
  9.     {
  10.         private ConcreteAggregate _aggregate;
  11.         private int _current = ;
  12.  
  13.         public ConcreteIterator(ConcreteAggregate aggregate)
  14.         {
  15.             this._aggregate = aggregate;
  16.         }
  17.  
  18.         public override object First()
  19.         {
  20.             return _aggregate[];
  21.         }
  22.  
  23.         public override object Next()
  24.         {
  25.             object ret = null;
  26.             if (_current < _aggregate.Count - )
  27.             {
  28.                 ret = _aggregate[++_current];
  29.             }
  30.  
  31.             return ret;
  32.         }
  33.  
  34.         public override object CurrentItem()
  35.         {
  36.             return _aggregate[_current];
  37.         }
  38.  
  39.         public override bool IsDone()
  40.         {
  41.             return _current >= _aggregate.Count;
  42.         }
  43.     }
  44. }

　　Program.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. using DesignPatterns.IteratorPattern.Structural;
  7.  
  8. namespace DesignPatterns.IteratorPattern
  9. {
  10.     class Program
  11.     {
  12.         static void Main(string[] args)
  13.         {
  14.             ConcreteAggregate a = new ConcreteAggregate();
  15.             a[] = "Item A";
  16.             a[] = "Item B";
  17.             a[] = "Item C";
  18.             a[] = "Item D";
  19.  
  20.             ConcreteIterator i = new ConcreteIterator(a);
  21.  
  22.             Console.WriteLine("Iterating over collection:");
  23.             object item = i.First();
  24.             while (item != null)
  25.             {
  26.                 Console.WriteLine(item);
  27.                 item = i.Next();
  28.             }
  29.         }
  30.     }
  31. }

　　运行输出：

  1. Iterating over collection:
  2. Item A
  3. Item B
  4. Item C
  5. Item D
  6. 请按任意键继续. . .

4、迭代器模式实践应用

　　在迭代器模式的设计中，有两种具体的实现方式，分别为外禀迭代器和内禀迭代器。白箱聚集与外禀迭代器：白箱聚集向外界提供访问自己内部元素的接口，从而使得外禀迭代器可以通过聚集提供的方法实现迭代功能。黑箱聚集与内禀迭代器：黑箱聚集不向外界提供遍历自己内部元素的接口，因此聚集的成员只能被聚集内部的方法访问。由于内禀迭代器恰好也是聚集的成员，因此可以访问聚集元素。

4.1、外禀迭代器

　　外禀迭代器的迭代过程使用了集合中的元素，通过集合向外界提供了访问自身内部元素的机会。

　　Iterator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.ExtrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个迭代器接口
  10.     /// </summary>
  11.     public interface Iterator
  12.     {
  13.         /// <summary>
  14.         /// 迭代器定位到聚合的第一个元素
  15.         /// </summary>
  16.         void First();
  17.  
  18.         /// <summary>
  19.         /// 遍历下一个
  20.         /// </summary>
  21.         void Next();
  22.  
  23.         /// <summary>
  24.         /// 判断是否完成遍历
  25.         /// </summary>
  26.         /// <returns></returns>
  27.         bool IsDone();
  28.  
  29.         /// <summary>
  30.         /// 获得当前遍历的项
  31.         /// </summary>
  32.         /// <returns></returns>
  33.         object CurrentItem();
  34.     }
  35. }

　　ConcreteIterator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.ExtrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义具体的迭代器类
  10.     /// </summary>
  11.     public class ConcreteIterator : Iterator
  12.     {
  13.         private ConcreteAggregate aggregate;
  14.         private int index = ;
  15.         private int size = ;
  16.  
  17.         /// <summary>
  18.         /// 根据不同的聚合类进行初始化
  19.         /// </summary>
  20.         /// <param name="aggregate"></param>
  21.         public ConcreteIterator(ConcreteAggregate aggregate)
  22.         {
  23.             this.aggregate = aggregate;
  24.             size = aggregate.Size();
  25.             index = ;
  26.         }
  27.  
  28.         public void First()
  29.         {
  30.             index = ;
  31.         }
  32.  
  33.         public void Next()
  34.         {
  35.             if (index < size)
  36.             {
  37.                 index++;
  38.             }
  39.         }
  40.  
  41.         /// <summary>
  42.         /// 判断是否遍历完毕
  43.         /// </summary>
  44.         /// <returns></returns>
  45.         public bool IsDone()
  46.         {
  47.             return index >= size;
  48.         }
  49.  
  50.         /// <summary>
  51.         /// 获取当前遍历的元素
  52.         /// </summary>
  53.         /// <returns></returns>
  54.         public object CurrentItem()
  55.         {
  56.             return aggregate.GetElement(index);
  57.         }
  58.     }
  59. }

　　Aggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.ExtrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个抽象的聚合类
  10.     /// </summary>
  11.     public abstract class Aggregate
  12.     {
  13.         /// <summary>
  14.         /// 只有一个功能，创建迭代器
  15.         /// </summary>
  16.         /// <returns></returns>
  17.         public virtual Iterator CreateIterator()
  18.         {
  19.             return null;
  20.         }
  21.     }
  22. }

　　ConcreteAggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.ExtrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个具体的聚合类
  10.     /// </summary>
  11.     public class ConcreteAggregate : Aggregate
  12.     {
  13.         // 存储元素的集合
  14.         private object[] objs = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
  15.  
  16.         /// <summary>
  17.         /// 获得元素个数
  18.         /// </summary>
  19.         /// <returns></returns>
  20.         public int Size()
  21.         {
  22.             return objs.Length;
  23.         }
  24.  
  25.         /// <summary>
  26.         /// 获取指定序号的元素
  27.         /// </summary>
  28.         /// <param name="index">指定的序号</param>
  29.         /// <returns></returns>
  30.         public object GetElement(int index)
  31.         {
  32.             if (index <  || index > objs.Length)
  33.             {
  34.                 return null;
  35.             }
  36.  
  37.             return objs[index];
  38.         }
  39.  
  40.         /// <summary>
  41.         /// 创建该聚合类的迭代器
  42.         /// </summary>
  43.         /// <returns></returns>
  44.         public override Iterator CreateIterator()
  45.         {
  46.             return new ConcreteIterator(this);
  47.         }
  48.     }
  49. }

　　Client.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.ExtrinsicIterator
  7. {
  8.     public class Client
  9.     {
  10.         private Iterator _iterator;
  11.         private Aggregate _aggregate = new ConcreteAggregate();
  12.  
  13.         public void Operation()
  14.         {
  15.             // 获得迭代器
  16.             _iterator = _aggregate.CreateIterator();
  17.  
  18.             while (!_iterator.IsDone())
  19.             {
  20.                 Console.WriteLine(_iterator.CurrentItem());
  21.                 _iterator.Next();
  22.             }
  23.         }
  24.  
  25.         static void Main(string[] args)
  26.         {
  27.             Client client = new Client();
  28.             client.Operation();
  29.         }
  30.     }
  31. }

　　运行输出：

  1. Sunday
  2. Monday
  3. Tuesday
  4. Wednesday
  5. Thursday
  6. Friday
  7. Saturday
  8. 请按任意键继续. . .

4.2、内禀迭代器

　　内禀迭代器实现的关键是在集合的内部定义一个私有的具体迭代子类，由它来负责迭代器的所有功能。因为它是集合的私有类，所以它的对象可以遍历集合的内部元素，实现迭代器定义的所有接口，而集合本身并未向外界提供访问自己内部元素的接口。

　　Iterator.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.IntrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个迭代器接口
  10.     /// </summary>
  11.     public interface Iterator
  12.     {
  13.         /// <summary>
  14.         /// 迭代器定位到聚合的第一个元素
  15.         /// </summary>
  16.         void First();
  17.  
  18.         /// <summary>
  19.         /// 遍历下一个
  20.         /// </summary>
  21.         void Next();
  22.  
  23.         /// <summary>
  24.         /// 判断是否完成遍历
  25.         /// </summary>
  26.         /// <returns></returns>
  27.         bool IsDone();
  28.  
  29.         /// <summary>
  30.         /// 获得当前遍历的项
  31.         /// </summary>
  32.         /// <returns></returns>
  33.         object CurrentItem();
  34.     }
  35. }

　　Aggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.IntrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个抽象的聚合类
  10.     /// </summary>
  11.     public abstract class Aggregate
  12.     {
  13.         /// <summary>
  14.         /// 只有一个功能，创建迭代器
  15.         /// </summary>
  16.         /// <returns></returns>
  17.         public virtual Iterator CreateIterator()
  18.         {
  19.             return null;
  20.         }
  21.     }
  22. }

　　ConcreteAggregate.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.IntrinsicIterator
  7. {
  8.     /// <summary>
  9.     /// 定义一个具体的聚合类
  10.     /// </summary>
  11.     public class ConcreteAggregate : Aggregate
  12.     {
  13.         // 存储元素的集合
  14.         private static object[] objs = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
  15.  
  16.         /// <summary>
  17.         /// 定义具体的迭代器类
  18.         /// </summary>
  19.         private class ConcreteIterator : Iterator
  20.         {
  21.             private int _index = ;
  22.  
  23.             public void First()
  24.             {
  25.                 _index = ;
  26.             }
  27.  
  28.             public void Next()
  29.             {
  30.                 if (_index < objs.Length)
  31.                 {
  32.                     _index++;
  33.                 }
  34.             }
  35.  
  36.             public bool IsDone()
  37.             {
  38.                 return _index == objs.Length;
  39.             }
  40.  
  41.             public object CurrentItem()
  42.             {
  43.                 return objs[_index];
  44.             }
  45.         }
  46.  
  47.         /// <summary>
  48.         /// 获得元素个数
  49.         /// </summary>
  50.         /// <returns></returns>
  51.         public int Size()
  52.         {
  53.             return objs.Length;
  54.         }
  55.  
  56.         /// <summary>
  57.         /// 获取指定序号的元素
  58.         /// </summary>
  59.         /// <param name="index">指定的序号</param>
  60.         /// <returns></returns>
  61.         public object GetElement(int index)
  62.         {
  63.             if (index <  || index > objs.Length)
  64.             {
  65.                 return null;
  66.             }
  67.  
  68.             return objs[index];
  69.         }
  70.  
  71.         /// <summary>
  72.         /// 创建该聚合类的迭代器
  73.         /// </summary>
  74.         /// <returns></returns>
  75.         public override Iterator CreateIterator()
  76.         {
  77.             return new ConcreteIterator();
  78.         }
  79.     }
  80. }

　　Client.cs

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6. namespace DesignPatterns.IteratorPattern.Practical.IntrinsicIterator
  7. {
  8.     public class Client
  9.     {
  10.         private Iterator _iterator;
  11.         private Aggregate _aggregate = new ConcreteAggregate();
  12.  
  13.         public void Operation()
  14.         {
  15.             // 获得迭代器
  16.             _iterator = _aggregate.CreateIterator();
  17.  
  18.             while (!_iterator.IsDone())
  19.             {
  20.                 Console.WriteLine(_iterator.CurrentItem());
  21.                 _iterator.Next();
  22.             }
  23.         }
  24.  
  25.         static void Main(string[] args)
  26.         {
  27.             Client client = new Client();
  28.             client.Operation();
  29.         }
  30.     }
  31. }

5、迭代器模式应用分析

　　迭代器模式适用情形：

　　1>、访问一个具体对象的内容而不暴露它的内部表示；

　　2>、支持对聚合对象的多种遍历；

　　3>、为遍历不同的聚合结构提供一个统一的接口（即支持多态迭代）。

　　迭代器模式特点：

　　1>、简化聚集的行为，迭代器具备了遍历的接口，这样聚集的接口就不必具备遍历接口；

　　2>、每一个聚集对象都可以有一个或者更多的迭代器对象，每一个迭代器的迭代状态可以彼此独立（外禀迭代器）；

　　3>、遍历算法被封装到迭代器对象中，迭代算法可以独立于聚集对象变化。Client不必知道聚集对象的类型，通过迭代器可以就读取和遍历聚集对象。这样的好处是聚集本身内部数据发生变化而不影响Client的程序。

C#设计模式系列：迭代器模式（Iterator）的更多相关文章

  1. 乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern)

    原文:乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern) [索引页][源码下载] 乐在其中设计模式(C#) - 迭代器模式(Iterator Pattern) 作者:weba ...

  2. 设计模式学习--迭代器模式(Iterator Pattern)和组合模式（Composite Pattern)

    设计模式学习--迭代器模式(Iterator Pattern) 概述 ——————————————————————————————————————————————————— 迭代器模式提供一种方法顺序 ...

  3. 二十四种设计模式：迭代器模式(Iterator Pattern)

    迭代器模式(Iterator Pattern) 介绍提供一种方法顺序访问一个聚合对象中各个元素,而又不需暴露该对象的内部表示. 示例有一个Message实体类,某聚合对象内的各个元素均为该实体对象,现 ...

  4. [设计模式] 16 迭代器模式 Iterator Pattern

    在GOF的<设计模式:可复用面向对象软件的基础>一书中对迭代器模式是这样说的:提供一种方法顺序访问一个聚合对象中各个元素,而又不需要暴露该对象的内部表示. 类图和实例: 迭代器模式由以下角 ...

  5. 设计模式之迭代器模式(Iterator)摘录

    23种GOF设计模式一般分为三大类:创建型模式.结构型模式.行为模式. 创建型模式抽象了实例化过程,它们帮助一个系统独立于怎样创建.组合和表示它的那些对象.一个类创建型模式使用继承改变被实例化的类,而 ...

  6. 设计模式 笔记 迭代器模式 Iterator

    //---------------------------15/04/26---------------------------- //Iterator 迭代器模式----对象行为型模式 /* 1:意 ...

  7. 行为型设计模式之迭代器模式(Iterator)

    结构 意图 提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示. 适用性 访问一个聚合对象的内容而无需暴露它的内部表示. 支持对聚合对象的多种遍历. 为遍历不同的聚合结构提供一 ...

  8. 设计模式之迭代器模式 Iterator

    代码实现 public interface MyIterator { void first(); //将游标指向第一个元素 void next(); //将游标指向下一个元素 boolean hasN ...

  9. Java 设计模式系列（十五）迭代器模式(Iterator)

    Java 设计模式系列(十五)迭代器模式(Iterator) 迭代器模式又叫游标(Cursor)模式,是对象的行为模式.迭代子模式可以顺序地访问一个聚集中的元素而不必暴露聚集的内部表象(interna ...

  10. 设计模式系列之迭代器模式(Iterator Pattern)——遍历聚合对象中的元素

    模式概述 模式定义 模式结构图 模式伪代码 模式改进 模式应用 模式在JDK中的应用 模式在开源项目中的应用 模式总结 说明:设计模式系列文章是读刘伟所著<设计模式的艺术之道(软件开发人员内功修 ...

随机推荐

  1. JDBC

    <java连接数据库> Class.forName("com.mysql.jdbc.Driver")--1:加载驱动 Connection conn=DriverMan ...

  2. 【BZOJ2073】[POI2004]PRZ 状压DP

    [BZOJ2073][POI2004]PRZ Description 一只队伍在爬山时碰到了雪崩,他们在逃跑时遇到了一座桥,他们要尽快的过桥. 桥已经很旧了, 所以它不能承受太重的东西. 任何时候队伍 ...

  3. 阿里云ECS（Centos）开启X11的步骤

    阿里云ECS(Centos)开启X11的步骤 1.修改sshd_config X11Forwarding yes 2.yum -y install xorg-x11-xauth xorg-x11-ut ...

  4. 来自XP的道别信

    当你们看到这封信的时候,很抱歉要和大家说再见了! 亲爱的你们,对不起,请不要为我哭泣,请让我们一起度过这最后的时光. 请记住那个在蓝天白云下奔跑的我!

  5. Spark优化之三：Kryo序列化

    Spark默认采用Java的序列化器,这里建议采用Kryo序列化提高性能.实测性能最高甚至提高一倍. Spark之所以不默认使用Kryo序列化,可能的原因是需要对类进行注册. Java程序中注册很简单 ...

  6. centos 7.2 安装PHP7.1+apache2.4.23

    安装准备:   http://ftp.cuhk.edu.hk/pub/packages/apache.org//httpd/httpd-2.4.23.tar.gz 下载apache http://cn ...

  7. java实现PDF转HTML

    问题场景: 在使用PB嵌入HTML页面时发现调不起查看PDF的插件 解决方法: 将PDF转换为HTML来展示 解决步骤: 1.下载PDF转换工具.exe 下载地址:http://pan.baidu.c ...

  8. bzoj3380: [Usaco2004 Open]Cave Cows 1 洞穴里的牛之一(spfa+状压DP)

    数据最多14个有宝藏的地方,所以可以想到用状压dp 可以先预处理出每个i到j的路径中最小权值的最大值dis[i][j] 本来想用Floyd写,无奈太弱调不出来..后来改用spfa 然后进行dp,这基本 ...

  9. 360急速浏览器BUG，POST表单提交参数丢失

    p{text-indent:2em;} --> 今天我在做支付宝充值的时候发现在360急速浏览器下面业务处理页面获取Request.Form参数为空,一开始我还以为是自己参数没有传递过去.然后就 ...

  10. canvas ：曲线的面积图 加渐变效果

    document.body.innerHTML = '<canvas></canvas>' var cvs = document.querySelector("can ...