17.Iterator迭代器（行为型模式）

已于 2022-09-03 12:27:14 修改
阅读量225 收藏
点赞数
分类专栏： c#设计模式 文章标签： c#
于 2022-09-02 17:29:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzyzxb/article/details/126662049
版权
本文详细介绍了迭代器模式，这是一种设计模式，用于在不暴露内部结构的情况下遍历聚合对象。通过将遍历行为分离到迭代器类，实现了数据结构的隐藏并提供了统一的遍历接口。生活中的例子如公交车售票员检票，代码示例展示了如何在.NET环境中实现迭代器模式。适用性包括访问聚合内容、支持多种遍历和统一接口。总结强调了迭代器模式的抽象性和多态性，以及在遍历过程中对集合结构的保护。
摘要由CSDN通过智能技术生成

一：动机（Motivation）

<1>在面向对象的软件设计中，我们经常会遇到一类集合对象，这类集合对象的内部结构可能有着各种各样的实现，但是归结起来，无非有两点是需要我们去关心的：一是集合内部的数据存储结构，二是遍历集合内部的数据。面向对象设计原则中有一条是类的单一职责原则，所以我们要尽可能的去分解这些职责，用不同的类去承担不同的职责。

<2>Iterator模式就是分离了集合对象的遍历行为，抽象出一个迭代器类来负责，这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部的数据。

二：意图（Intent）

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

三：结构（Structure）

在这里插入图片描述

四：结构详解

在这里插入图片描述

五：生活中的例子

<1>在公交车上，售票员不管上来的是什么人，总会要求每个人都来买票。
<2>不管乘客是什么，售票员的做法都是相同的：
从第一个开始
当前是谁
下一个
是否结束

六：实现

namespace Test
{
    /// <summary>
    /// 迭代器，用来执行迭代操作
    /// </summary>
    public abstract class Iterator
    {
        public abstract object First();  //第一个
        public abstract object CurrentItem();  //当前这一个
        public abstract object Next();  //下一个
        public abstract bool IsDone();  //结束了没有？
    }

    /// <summary>
    /// 聚合类，代表一个可迭代的集合
    /// </summary>
    public abstract class Aggregate
    {
        public abstract Iterator CreateIterator();  //返回一个迭代器
    }

    /// <summary>
    /// ConcreteAggregate  具体的聚合类
    /// </summary>
    public class 车上的乘客 : Aggregate
    {
        private System.Collections.ArrayList al = new System.Collections.ArrayList();

        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }

        public void 上车(string 乘客姓名)
        {
            this.al.Add(乘客姓名);
        }

        public string this[int index]
        {
            get
            {
                return this.al[index].ToString();
            }
        }

        public int 数量
        {
            get
            {
                return this.al.Count;
            }
        }
    }

    /// <summary>
    /// ConcreteIterator  具体的迭代器
    /// </summary>
    public class ConcreteIterator : Iterator
    {
        private 车上的乘客 _乘客们 = null;

        private int 当前第几个 = 0;

        public ConcreteIterator(车上的乘客 乘客)
        {
            this._乘客们 = 乘客;
        }

        public override object First()
        {
            if (this._乘客们.数量 > 0)
            {
                this.当前第几个 = 0;
                return this._乘客们[0];
            }
            else
            {
                return null;
            }
        }

        public override object CurrentItem()
        {
            return this._乘客们[当前第几个];
        }

        public override object Next()
        {
            this.当前第几个++;
            if (this.当前第几个 < this._乘客们.数量)
            {
                return this._乘客们[当前第几个];
            }
            else
            {
                return null;
            }
        }

        public override bool IsDone()
        {
            return this.当前第几个 >= this._乘客们.数量;
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            车上的乘客 隧道六线 = new 车上的乘客();
            隧道六线.上车("张三");
            隧道六线.上车("李四");
            隧道六线.上车("王五");
            隧道六线.上车("赵六");

            Iterator iterator = 隧道六线.CreateIterator();

            while (!iterator.IsDone())
            {
                Console.WriteLine("{0},请你买票,谢谢!", iterator.CurrentItem());
                iterator.Next();
            }
            Console.ReadLine();
        }
    }
}

在这里插入图片描述

七：适用性

<1>访问一个聚合对象的内容而无需暴露它的内部表示。
<2>支持对聚合对象的多种遍历。
<3>为遍历不同的聚合结构提供一个统一的接口（即，支持多态迭代）。

namespace Test
{
    /// <summary>
    /// 聚合对象(集合)
    /// </summary>
    public abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

    /// <summary>
    /// 迭代器：能遍历一个集合的遍历行为
    /// </summary>
    public abstract class Iterator
    {
        public abstract object First();
        public abstract void Next();
        public abstract object Current();
        public abstract bool IsDone
        {
            get;
        }
    }

    /// <summary>
    /// 一年级
    /// </summary>
    public class FirstGrade : Aggregate
    {
        public override Iterator CreateIterator()
        {
            //return new FirstGradeAsceIterator(this);
            return new FirstGradeDeAsceIterator(this);
        }

        private List<Student> students = new List<Student>();
        public void AddStudent(Student student)
        {
            this.students.Add(student);
        }

        public int StudentsCount
        {
            get { return this.students.Count; }
        }

        public Student this[int index]
        {
            get { return this.students[index]; }
        }
    }

    public class Student
    {
        public Student(string name)
        {
            this.Name = name;
        }

        public string Name { get; set; }
        public override string ToString()
        {
            return this.Name;
        }
    }

    /// <summary>
    /// 按照升序迭代
    /// </summary>
    public class FirstGradeAsceIterator : Iterator
    {
        /// <summary>
        /// 关联到需要迭代的一年级班级(集合)
        /// </summary>
        private FirstGrade? myClass = null;

        /// <summary>
        /// 对班级的依赖
        /// </summary>
        /// <param name="myClassToIterator"></param>
        public FirstGradeAsceIterator(FirstGrade myClassToIterator)
        {
            this.myClass = myClassToIterator;
        }

        private int currentIndex = 0;

        public override object Current()
        {
            return this.myClass[this.currentIndex];
        }

        public override object First()
        {
            return this.myClass[0];
        }

        public override void Next()
        {
            this.currentIndex++;
        }

        public override bool IsDone
        {
            get
            {
                return this.currentIndex == this.myClass.StudentsCount;
            }
        }
    }

    /// <summary>
    /// 按照降序迭代
    /// </summary>
    public class FirstGradeDeAsceIterator : Iterator
    {
        /// <summary>
        /// 关联到需要迭代的一年级班级(集合)
        /// </summary>
        private FirstGrade? myClass = null;

        private int currentIndex;

        /// <summary>
        /// 对班级的依赖
        /// </summary>
        /// <param name="myClassToIterator"></param>
        public FirstGradeDeAsceIterator(FirstGrade myClassToIterator)
        {
            this.myClass = myClassToIterator;
            currentIndex = myClass.StudentsCount - 1;
        }

        public override object Current()
        {
            return this.myClass[this.currentIndex];
        }

        public override object First()
        {
            return this.myClass[myClass.StudentsCount - 1];
        }

        public override void Next()
        {
            this.currentIndex--;
        }

        public override bool IsDone
        {
            get
            {
                return this.currentIndex == -1;
            }
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            FirstGrade firstGrade = new FirstGrade();
            firstGrade.AddStudent(new Student("张三"));
            firstGrade.AddStudent(new Student("李四"));
            firstGrade.AddStudent(new Student("王五"));

            Iterator iterator = (firstGrade as Aggregate).CreateIterator();
            while (!iterator.IsDone)
            {
                object current = iterator.Current();
                Console.WriteLine(current);
                iterator.Next();
            }
            Console.ReadLine();
        }
    }
}

namespace Test
{
    /// <summary>
    /// 聚合对象(集合)
    /// </summary>
    public abstract class Aggregate
    {
        public abstract Iterator CreateIterator();
    }

    /// <summary>
    /// 迭代器：能遍历一个集合的遍历行为
    /// </summary>
    public abstract class Iterator
    {
        public abstract object First();
        public abstract void Next();
        public abstract object Current();
        public abstract bool IsDone
        {
            get;
        }
    }

    /// <summary>
    /// 一年级
    /// </summary>
    public class FirstGrade : Aggregate
    {
        public override Iterator CreateIterator()
        {
            return new FirstGradeAsceIterator(this);
            //return new FirstGradeDeAsceIterator(this);
        }

        private List<Student> students = new List<Student>();
        public void AddStudent(Student student)
        {
            this.students.Add(student);
        }

        /// <summary>
        /// 按照升序迭代
        /// </summary>
        private class FirstGradeAsceIterator : Iterator
        {
            /// <summary>
            /// 关联到需要迭代的一年级班级(集合)
            /// </summary>
            private FirstGrade? myClass = null;

            /// <summary>
            /// 对班级的依赖
            /// </summary>
            /// <param name="myClassToIterator"></param>
            public FirstGradeAsceIterator(FirstGrade myClassToIterator)
            {
                this.myClass = myClassToIterator;
            }

            private int currentIndex = 0;

            public override object Current()
            {
                return this.myClass.students[this.currentIndex];
            }

            public override object First()
            {
                return this.myClass.students[0];
            }

            public override void Next()
            {
                this.currentIndex++;
            }

            public override bool IsDone
            {
                get
                {
                    return this.currentIndex == this.myClass.students.Count;
                }
            }
        }

        /// <summary>
        /// 按照降序迭代
        /// </summary>
        private class FirstGradeDeAsceIterator : Iterator
        {
            /// <summary>
            /// 关联到需要迭代的一年级班级(集合)
            /// </summary>
            private FirstGrade? myClass = null;

            private int currentIndex;

            /// <summary>
            /// 对班级的依赖
            /// </summary>
            /// <param name="myClassToIterator"></param>
            public FirstGradeDeAsceIterator(FirstGrade myClassToIterator)
            {
                this.myClass = myClassToIterator;
                currentIndex = myClass.students.Count - 1;
            }

            public override object Current()
            {
                return this.myClass.students[this.currentIndex];
            }

            public override object First()
            {
                return this.myClass.students[myClass.students.Count - 1];
            }

            public override void Next()
            {
                this.currentIndex--;
            }

            public override bool IsDone
            {
                get
                {
                    return this.currentIndex == -1;
                }
            }
        }
    }

    public class Student
    {
        public Student(string name)
        {
            this.Name = name;
        }

        public string Name { get; set; }
        public override string ToString()
        {
            return this.Name;
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            FirstGrade firstGrade = new FirstGrade();
            firstGrade.AddStudent(new Student("张三"));
            firstGrade.AddStudent(new Student("李四"));
            firstGrade.AddStudent(new Student("王五"));

            Iterator iterator = (firstGrade as Aggregate).CreateIterator();
            while (!iterator.IsDone)
            {
                object current = iterator.Current();
                Console.WriteLine(current);
                iterator.Next();
            }
            Console.ReadLine();
        }
    }
}

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

namespace Test
{
    public class 车上的乘客NET : System.Collections.IEnumerable
    {
        private System.Collections.ArrayList al = new System.Collections.ArrayList();
        public void 上车(string 乘客姓名)
        {
            this.al.Add(乘客姓名);
        }
        public string this[int index]
        {
            get { return this.al[index].ToString(); }
        }
        public int 数量
        {
            get { return this.al.Count; }
        }
        #region IEnumerable 成员
        public System.Collections.IEnumerator GetEnumerator()
        {
            return new ConcreteIteratorNET(this);
        }
        #endregion
    }

    public class 车上的乘客NET2 : System.Collections.IEnumerable
    {
        private System.Collections.ArrayList al = new System.Collections.ArrayList();

        public void 上车(string 乘客姓名)
        {
            this.al.Add(乘客姓名);
        }
        #region IEnumerable 成员

        public System.Collections.IEnumerator GetEnumerator()
        {
            foreach (object var in this.al)
            {
                yield return var;
            }
        }
        #endregion
    }

    public class ConcreteIteratorNET : System.Collections.IEnumerator
    {
        private 车上的乘客NET _乘客们 = null;
        private int 当前第几个 = -1;
        public ConcreteIteratorNET(车上的乘客NET 乘客)
        {
            this._乘客们 = 乘客;
        }
        #region IEnumerator 成员
        public object Current
        {
            get { return this._乘客们[当前第几个]; }
        }
        public bool MoveNext()
        {
            this.当前第几个++;
            return this.当前第几个 < this._乘客们.数量;
        }
        public void Reset()
        {
            this.当前第几个 = -1;
        }
        #endregion
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            车上的乘客NET 隧道六线 = new 车上的乘客NET();
            隧道六线.上车("张三");
            隧道六线.上车("李四");
            隧道六线.上车("王五");
            隧道六线.上车("赵六");
            System.Collections.IEnumerator iterator = 隧道六线.GetEnumerator();

            while (iterator.MoveNext())
            {
                Console.WriteLine("{0},请你买票,谢谢!", iterator.Current);
            }

            Console.ReadLine();
        }
    }
}

八：总结

<1>迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
<2>迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行操作。
<3>迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，会导致问题。

zzyzxb
关注
专栏目录
Golang与设计模式-Iterator迭代器模式
Lyon_Nee的博客
08-07 1100
迭代器模式在Java和C#中常用到的设计模式，这种模式主要用于对于集合（Aggregate）的有序访问。 一般情况下Golang的开发中是不需要使用到的，像Slice跟Array都可以通过for...range...来完成遍历。但不是说一定就用不上哦。 接口 首先，我们知道迭代器模式主要适用于数据集合，那么我们就可以定义一个集合（Aggregate）接口，这个接口只有一个方法，就是返回给我们一个迭代器（Iterator）。 // 集合接口 type Aggregate interface { /
迭代器(Iterator)模式
qq_38636211的博客
07-30 1588
文章目录迭代器(Iterator)模式1. 意图2. 别名3. 动机4. 适用性5. 结构6. 参与者7. 协作8. 效果9. 实现10. 代码示例11. 已知应用12. 相关模式13. 设计原则口袋14. 参考文献 迭代器(Iterator)模式 隶属类别——对象行为型模式 1. 意图 提供一个方法顺序访问一个聚合对象中各个元素，而又不需要暴露该对象的内部表示 2. 别名 游标(Cursor)...
设计模式-迭代器模式（Iterator）
miaoyl的博客
11-11 871
迭代器模式是一种设计模式，它用于提供一种方法来访问一个容器对象中的各个元素，而又不暴露该对象的内部表示。在迭代器模式中，我们定义一个抽象的迭代器类，它包含两个方法：一个是hasNext()方法，用于判断是否还有下一个元素；另一个是next()方法，用于获取下一个元素。然后，每个容器类都实现自己的迭代器类，以访问容器中的元素。
设计模式第16讲——迭代器模式（Iterator）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-25 7620
迭代器模式是一种行为型设计模式。一、什么是迭代器模式 二、角色组成 三、 优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现5.0 UML类图 5.1 Student——学生实体类5.2 StudentIterator——抽象迭代器（Iterator）5.3 StudentListIterator——具体迭代器（Concrete iterator）5.4 StudentAggregate——抽象聚合器（Aggregate）5.5 ClassList
行为型-迭代器模式（Iterator）
最新发布
jonas80029735的博客
10-16 803
提供一个对象来顺序访问聚合对象（列表、 栈和树等）中的一系列数据，而不暴露聚合对象的内部表现形式。
17.Iterator-迭代器模式
龙叔的博客
05-10 968
Iterator 迭代器模式 迭代器模式: 提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。 迭代器模式就是顺序访问聚集中的对象，一般来说，集合中非常常见，如果对集合类比较熟悉的话，理解本模式会十分轻松。 这句话包含两层意思：一是需要遍历的对象，即聚集对象，二是迭代器对象，用于对聚集对象进行遍历访问. 示例类图:
3.4设计模式——Iterator 迭代器模式（行为型）
笑醉踏歌行
04-23 541
提供一个方法顺序访问一个聚合对象中的各个元素，且不需要暴漏该对象的内部表示。
C++设计模式——Iterator迭代器模式
CoderZZ_2024的博客
09-11 1095
迭代器模式是一种。
设计模式-行为型模式-迭代器模式 Iterator
weixin_44244088的博客
05-29 168
设计模式-行为型模式-迭代器模式 Iterator 1.简介 用于容器和容器遍历；容器可以是数组，列表，集合 或者其他的容器型数据结构 迭代器模式提供一种顺序遍历聚合对象元素而不暴露其内部实现方式的方法； 2.角色 Container/Aggregate ： 容器类接口 ConcreteContainer/ConcreteAggregate ：具体容器类的实现类，暴露方法创建迭代器 Iterator：迭代器接口，具有通用方法，hasNext();next() ConcreteIterator：一般容器内
设计模式-迭代器模式Iterator（行为型）
qq_43676797的博客
06-15 445
迭代器模式属于行为型模式，用来遍历容器的一种模式。
(行为型模式) Iterator 迭代器模式
09-29
### (行为型模式) Iterator 迭代器模式 #### 概述 在软件工程领域，设计模式被广泛应用于解决常见的编程问题。其中，“迭代器模式”作为一种行为型设计模式，在处理集合类对象时发挥着重要作用。本文将详细介绍...
PHP设计模式之迭代器模式Iterator实例分析【对象行为型】
12-17
迭代器模式（Iterator Pattern）是设计模式中的一种对象行为型模式，主要解决如何在不暴露内部结构的情况下遍历一个聚合对象的问题。在PHP中，迭代器模式允许我们以一致的方式遍历不同类型的集合，比如数组、对象...
设计模式C++学习之迭代器模式（Iterator）
09-07
迭代器模式是软件设计模式中的行为模式之一，它在C++编程中有着广泛的应用。这个模式提供了一种方法来顺序访问聚合对象的元素，而无需暴露其底层表示。通过迭代器，用户可以遍历集合中的所有元素，而无需知道如何...
C#的Task中ConfigureAwait用法
qq565221961的博客
10-14 377
ConfigureAwait方法在异步编程中扮演着重要的角色，通过配置任务的运行上下文，可以对任务的执行和调度进行灵活控制，从而提高应用程序的性能和响应能力。但在使用时需要注意场景和参数的选择，以确保任务的正确执行和应用程序的稳定性。在.NET开发中，合理地使用ConfigureAwait方法可以帮助我们优化异步代码的性能，提高应用程序的用户体验。希望本篇博客对读者有所帮助，能够在实际开发中更加灵活地运用ConfigureAwait方法。
C#实现数字到人民币大写金额的转换
学习和分享
10-13 337
在开发会计软件或企业资源规划（ERP）系统时，为了满足客户的特定需求，可能会集成这个功能，以便在生成相关文档时自动将数字转换为人民币大写形式。：虽然银行系统内部通常使用数字形式记录交易金额，但在提供给客户的对账单或交易记录中，可能会包含人民币大写形式的金额，以便客户更容易核对和理解。：在编制财务报表时，特别是需要对外公布的报表，如年度财务报告，可能会将某些关键数字以人民币大写形式呈现，以提高可读性和正式性。：在生成发票或收据时，通常需要将金额以人民币大写形式打印出来，以防止篡改，并作为法律上的有效凭证。
Win32获取系统版本信息
FlameCyclone的博客
10-12 393
精确获取Windows系统版本信息
GO Practise
程序媛平平无奇的一天
10-12 554
练习：切片 练习：映射 练习：斐波纳契闭包 练习：Stringer 练习：错误
C#学习笔记（三）
m0_53264919的博客
10-15 429
第 二 章 命名空间和类、数据类型、变量和代码规范 二、类的组成和使用分析 1. 基本概念 2. 类的内容组成 3. 方法的初步理解
C# 文件夹类的实现与文件属性处理
hspx668的博客
10-11 591
4. **创建日期**： 使用 `DirectoryInfo` 的 `CreationTime` 属性可以获得文件夹的创建时间。2. **文件路径**： 文件夹的完整路径可以通过 `DirectoryInfo` 的 `FullName` 属性获取。1. **文件名**： 文件夹的名称可以通过 `DirectoryInfo` 的 `Name` 属性获取。- **File** 和 **Directory**：提供静态方法来创建、删除和移动文件或文件夹。- **FileInfo**：用于获取文件的相关信息。
Java设计模式：行为型模式——迭代器模式详解
"JAVA-设计模式-行为型模式-迭代器模式" 迭代器模式是一种行为设计模式，它允许我们顺序访问聚合对象的元素，而无需暴露其内部结构。这种模式将遍历任务从聚合对象转移到专门的迭代器对象，使得聚合类能够专注于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值