C#设计模式读书笔记之迭代器模式 (Iterator Pattern)

迭代器模式 (Iterator Pattern)【使用频率：★★★★★】

1. 概述：

　　所谓迭代器模式就是提供一种方法顺序访问一个聚合对象中的各个元素，而不是暴露其内部的表示。

2. 模式中的角色

　　2.1 Iterator（抽象迭代器）：它定义了访问和遍历元素的接口，声明了用于遍历数据元素的方法，例如：用于获取第一个元素的first()方法，用于访问下一个元素的next()方法，用于判断是否还有下一个元素的hasNext()方法，用于获取当前元素的currentItem()方法等，在具体迭代器中将实现这些方法。

       2.2 ConcreteIterator（具体迭代器）：它实现了抽象迭代器接口，完成对聚合对象的遍历，同时在具体迭代器中通过游标来记录在聚合对象中所处的当前位置，在具体实现时，游标通常是一个表示位置的非负整数。

       2.3 Aggregate（抽象聚合类）：它用于存储和管理元素对象，声明一个createIterator()方法用于创建一个迭代器对象，充当抽象迭代器工厂角色。

       2.4 ConcreteAggregate（具体聚合类）：它实现了在抽象聚合类中声明的createIterator()方法，该方法返回一个与该具体聚合类对应的具体迭代器ConcreteIterator实例。

3. 模式解读

　　3.1 模式的类图

     3.2 代码实现

using System;
using System.Collections.Generic;

namespace ConsoleApp2
{
    class Class25
    {
        static void Main(string[] args)
        {
            TVChanneMenu tvMenu = new TVChanneMenu();
            FilmMenu filmMenu = new FilmMenu();

            MainMenu mainMenu = new MainMenu(tvMenu, filmMenu);
            mainMenu.PrintMenu();

            Console.ReadLine();
        }
    }

    // 抽象迭代器
    public interface Iterator
    {
        bool HasNext();
        object Next();
    }

    // 具体迭代器
    public class FilmMenuIterator : Iterator
    {
        MenuItem[] menuItems;
        int position = 0;


        public FilmMenuIterator(MenuItem[] menuItems)
        {
            this.menuItems = menuItems;
        }

        public bool HasNext()
        {
            if (position > menuItems.Length - 1 || menuItems[position] == null)
            {
                return false;
            }
            return true;
        }

        public object Next()
        {
            MenuItem menuItem = menuItems[position];
            position++;
            return menuItem;
        }
    }

    // 具体迭代器
    public class TVChanneMenuIterator : Iterator
    {
        List<MenuItem> menuItems;
        int position = 0;

        public TVChanneMenuIterator(List<MenuItem> menuItems)
        {
            this.menuItems = menuItems;
        }

        public bool HasNext()
        {
            if (position > menuItems.Count - 1 || menuItems[position] == null)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public object Next()
        {
            MenuItem menuItem = menuItems[position];
            position++;
            return menuItem;
        }
    }

    // 抽象聚合类
    public interface ITelevisionMenu
    {
        void AddItem(int channe, string name, string description);
        Iterator CreateIrerator();
    }

    // 具体聚合类
    public class FilmMenu : ITelevisionMenu
    {
        const int MAX_ITEMS = 5;    //菜单最大长度
        MenuItem[] menuItems;
        int numberOfItems = 0;

        // 构造函数完成初始化
        public FilmMenu()
        {
            menuItems = new MenuItem[MAX_ITEMS];

            AddItem(1, "绝世天劫", "这是布鲁斯威利斯主演的...");
            AddItem(2, "达芬奇密码", "这是我最喜欢的电影之一...");
            AddItem(3, "黑客帝国123", "不知道你能够看懂不???");
            AddItem(4, "我的女友是机器人", "一部我不反感的经典爱情电影...");
            AddItem(5, "肖申克的救赎", "自由，幸福，离你有多远");
        }

        // 将电影解决添加到菜单项中
        public void AddItem(int channe, string name, string description)
        {
            MenuItem tvmenuiItem = new MenuItem(channe, name, description);
            //判断数组是否越界
            if (numberOfItems > MAX_ITEMS)
            {
                Console.WriteLine("不好意思，菜单满了....");
            }
            else
            {
                menuItems[numberOfItems] = tvmenuiItem;
                numberOfItems++;
            }
        }

        public Iterator CreateIrerator()
        {
            return new FilmMenuIterator(menuItems);
        }
    }

    // 具体聚合类
    public class TVChanneMenu : ITelevisionMenu
    {
        List<MenuItem> menuItems;

        // 构造函数完成初始化
        public TVChanneMenu()
        {
            menuItems = new List<MenuItem>();
            AddItem(1, "CCTV-1", "This is CCTV-1");
            AddItem(2, "CCTV-2", "This is CCTV-2");
            AddItem(3, "CCTV-3", "This is CCTV-3");
            AddItem(4, "CCTV-4", "This is CCTV-4");
            AddItem(5, "CCTV-5", "This is CCTV-5");
        }

        // 将电视频道节目添加菜单集合中
        public void AddItem(int channe, string name, string description)
        {
            MenuItem tvMenuItem = new MenuItem(channe, name, description);
            menuItems.Add(tvMenuItem);
        }

        public Iterator CreateIrerator()
        {
            return new TVChanneMenuIterator(menuItems);
        }
    }

    public class MenuItem
    {
        private string name;
        private string description;
        private int channe;

        public MenuItem(int channe, string name, string description)
        {
            this.name = name;
            this.description = description;
            this.channe = channe;
        }

        public string getName()
        {
            return name;
        }

        public void setName(string name)
        {
            this.name = name;
        }

        public string getDescription()
        {
            return description;
        }

        public void setDescription(string description)
        {
            this.description = description;
        }

        public int getChanne()
        {
            return channe;
        }

        public void setChanne(int channe)
        {
            this.channe = channe;
        }
    }

    public class MainMenu
    {
        ITelevisionMenu tvMenu;
        FilmMenu filmMenu;

        public MainMenu(ITelevisionMenu tvMenu, FilmMenu filmMenu)
        {
            this.tvMenu = tvMenu;
            this.filmMenu = filmMenu;
        }

        public void PrintMenu()
        {
            Iterator tvIterator = tvMenu.CreateIrerator();
            Iterator filmIterator = filmMenu.CreateIrerator();

            Console.WriteLine("电视节目有:");
            PrintMenu(tvIterator);
            Console.WriteLine("----------------------------------------------------------------");
            Console.WriteLine("电影节目有:");
            PrintMenu(filmIterator);
        }

        private void PrintMenu(Iterator iterator)
        {
            while (iterator.HasNext())
            {
                MenuItem menuItem = (MenuItem)iterator.Next();
                Console.WriteLine("channe:" + menuItem.getChanne() + ",  ");
                Console.WriteLine("name:" + menuItem.getName() + ",  ");
                Console.WriteLine("description :" + menuItem.getDescription());
            }
        }
    }
}

4. 模式优缺点

　　4.1 优点：

       (1) 它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器的子类以支持新的遍历方式。

       (2) 迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。

       (3) 在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足“开闭原则”的要求。

　　　
　　4.2 缺点：

由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。

 

5. 使用场景：

       (1) 访问一个聚合对象的内容而无须暴露它的内部表示。将聚合对象的访问与内部数据的存储分离，使得访问聚合对象时无须了解其内部实现细节。

       (2) 需要为一个聚合对象提供多种遍历方式。

       (3) 为遍历不同的聚合结构提供一个统一的接口，在该接口的实现类中为不同的聚合结构提供不同的遍历方式，而客户端可以一致性地操作该接口。