设计模式-行为型-迭代器模式

设计模式-行为型-迭代器模式

---

---

前言

比如物流中心的分拣流水线，不需要管快递具体是什么物品，全部由传送带进行传输，物品都被统一传递，并且有一个统一类型的标识码，传送带就是我们的迭代器。
我们将多个对象组成的整体叫做集合（Aggregate）,集合对象是可以包含一组对象的容器对象，不同集合对象的聚合结构可能不同,迭代器的作用是屏蔽了内部的不同细节，为外部提供统一的访问行为。

---

一、迭代器模式（iterator pattern）

对外提供一致的访问方法，可以顺序访问一个聚合对象中的各个元素。统一对集合的访问方式。

二、角色分析

1. 抽象迭代器（Iterator）：定义访问及遍历元素的接口。
2. 具体迭代器（ConcreteIterator）：提供具体的元素遍历行为。
3. 抽象容器（IAggregate）：定义提供具体迭代器的接口。
4. 具体容器（ConcreteAggregate）：创建具体迭代器。
   总结： 通过以上说明迭代器为对外提供操作的行为，而容器是list内部管理的方法，并可以通过容器来创建获取对应的迭代器，并通过迭代器实现集合对象的访问。

三、应用场景

• 访问一个集合对象的内容而无须暴露他的内部表示
• 为便利不同的集合结构提供一个统一的访问接口

四、编码

1.抽象迭代器

作用：抽象迭代器（定义访问和遍历元素的接口）

 	/// <summary>
    /// 抽象迭代器（定义访问和遍历元素的接口）
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface Iterator<T>
    {
        T Next();
        bool HasNext();
    }

2.具体迭代器

作用：具体迭代器，内部对象管理行为实现

	/// <summary>
    /// 具体迭代器
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConcreteIterator<T> : Iterator<T>
    {
        private List<T> list;
        private int Cursor = 0;
        public ConcreteIterator(List<T> pramsList)
        {
            list = pramsList;
        }
        /// <summary>
        /// 判断当前集合对象后是否存在集合对象
        /// </summary>
        /// <returns></returns>
        public bool HasNext()
        {
            return this.Cursor < list.Count;
        }
 		/// <summary>
        /// 获取下一个集合对象
        /// </summary>
        /// <returns></returns>
        public T Next()
        {
            Console.Write($"{Cursor}----{list[Cursor]}");
            return this.list[Cursor++];
        }
    }

3.抽象容器

作用：抽象容器：对外的抽象管理行为

	/// <summary>
    /// 抽象容器
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IAggregate<T>
    {
        bool Add(T tEntity);
        bool remove(T tEntity);

        Iterator<T> Iterator();
    }

4.具体容器

作用：集合对象的存储位置，以及对象内部管理方法的实现。可以通过容器获得对应的迭代器。

	/// <summary>
    /// 具体容器
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConcreteIAggregate<T> : IAggregate<T>
    {
        private List<T> listT = new List<T>();
        /// <summary>
        /// 将对象添加到容器集合
        /// </summary>
        /// <param name="tEntity"></param>
        /// <returns></returns>
        public bool Add(T tEntity)
        {
            try
            {
                Console.WriteLine("将对象添加到集合容器");
                this.listT.Add(tEntity);
                return true;
            }
            catch (Exception error)
            {
                return false;
            }
        }
        /// <summary>
        /// 创建迭代器
        /// </summary>
        /// <returns></returns>
        public Iterator<T> Iterator()
        {
            return new ConcreteIterator<T>(listT);
        }
        /// <summary>
        /// 删除对象
        /// </summary>
        /// <param name="tEntity"></param>
        /// <returns></returns>
        public bool remove(T tEntity)
        {
            try
            {
                Console.WriteLine("将对象从集合容器删除");
                this.listT.Remove(tEntity);
                return true;
            }
            catch (Exception error)
            {
                return false;
            }
        }
    }

5.客户端调用

作用：客户端调用，迭代器模式的具体调用方法

	/// <summary>
	/// 客户端调用
	/// </summary>
	/// <returns></returns>
	 public void DoMain()
        {
	        //实例化具体容器并添加吊带其对象
            IAggregate<string> aggregate = new ConcreteIAggregate<string>();
            aggregate.Add("One");
            aggregate.Add("Two");
            aggregate.Add("Three");
            aggregate.Add("Four");
            aggregate.Add("Five");
            //获取容器中的迭代器
            Iterator<string> iterator = aggregate.Iterator();
            //通过迭代器中的行为方法，管理容器中的对象。
            while (iterator.HasNext())
            {
                string element = iterator.Next();
                Console.WriteLine($"{element}");
            }
        }

6.输出内容

作用：输出日志

将对象添加到集合容器
将对象添加到集合容器
将对象添加到集合容器
将对象添加到集合容器
将对象添加到集合容器
0----OneOne
1----TwoTwo
2----ThreeThree
3----FourFour
4----FiveFive

---

总结

优点

• 为不同的聚合结构提供一致的遍历接口
• 简化集合对象接口，将集合对象本身应提供的元素管理接口放置到迭代器中，使集合对象无须关心集体的迭代行为。
• 每个集合对象都可以提供一个或多个不同的迭代器，使得同种元素的聚合结构可以有不同的迭代行为。
• 迭代器模式封装了具体的迭代算法，迭代算法的变化不会影响到集合对象的架构

缺点

• 使用迭代器进行便利较为繁琐
• 一般应该用在需要定制化的数据结构对应的迭代器中。