10 迭代器模式

迭代器模式（Iterator）定义:提供一种顺序访问聚合对象中各个元素的方法，而又不暴露其内部的表示。

实际上现在很多语言都自带迭代器，无需我们单独实现，比如c#中的foreach-in，但通过学习迭代器模式，我们可以看到类似foreach-in这种语法背后的逻辑，同时感受一下GOF所在的那个时代大神们的创造力。

c#中foreach-in是语言内置迭代器的语法糖，List、数组、Dictionary等等都可以使用foreach方便地遍历，这也正是迭代器的好处，被遍历的对象不需要暴露自己内部的表示，这样遍历的代码就可以和被遍历对象解耦。

类图如下：

示例代码使用Head Forst设计模式中的例子，煎饼屋的菜单PancakeHouseMenu使用List存放，餐厅的菜单DinerMenu使用数组存放，两者合并后，为了能够统一地展示他们的菜单项，使用迭代器模式处理

代码如下：

 MenuItem规定了菜单的统一格式

class MenuItem
    {
        public MenuItem(string name, string description, bool isVegetarian, double price)
        {
            this.name = name;
            this.description = description;
            this.isVegetarian = isVegetarian;
            this.price = price;
        }
        string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        string description;

        public string Description
        {
            get { return description; }
            set { description = value; }
        }
        bool isVegetarian;

        public bool IsVegetarian
        {
            get { return isVegetarian; }
            set { isVegetarian = value; }
        }
        double price;

        public double Price
        {
            get { return price; }
            set { price = value; }
        }
    }

DinerMenu类

class DinerMenu
    {
        static readonly int MAX_ITEMS = 6;
        int numberOfItems = 0;
        MenuItem[] menuItem;
        public DinerMenu()
        {
            menuItem = new MenuItem[MAX_ITEMS];
            AddItem("Vegetarian BLT",
                          "(Fakin') Bacon with lettuce&tomato on whole wheat",
                            true, 2.99);
            AddItem("BLT",
                          "Bacon with lettuce&tomato on whole wheat",
                            false, 2.99);
            AddItem("Soup of the Day",
                          "Soup of the Day, with a side of potato salad",
                            false, 3.29);
            AddItem("HotDog",
                          "A hot dog, with saurkraut, relish, onions, topped with chesse",
                            false, 3.05);

        }

        public void AddItem(string name, string description, bool isVegetarian, double price)
        {
            MenuItem item = new MenuItem(name, description, isVegetarian, price);
            if (numberOfItems >= MAX_ITEMS)
            {
                Console.WriteLine("Over Flow!!!");
            }
            else
            {
                menuItem[numberOfItems] = item;
                numberOfItems++;
            }
        }

        public MenuItem[] GetMenuItems()
        {
            return menuItem;
        }

        public Iterator CreateIterator()
        {
            return new DinerMenuIterator(menuItem);
        }
    }

PancakeHouseMenu类

class PancakeHouseMenu
    {
        List<MenuItem> listMenu = new List<MenuItem>();
        public PancakeHouseMenu()
        {
            MenuItem item = new MenuItem(
                "K&B's Pancake Breakfast",
                "Pancakes with scrambled eggs, and toast",
                true,
                2.99);
            listMenu.Add(item);
            item = new MenuItem(
               "Regular Pancake Breakfast",
               "Pancakes with fired eggs, sausage",
               false,
               2.99);
            listMenu.Add(item);
            item = new MenuItem(
               "Blueberry Pancake",
               "Pancakes made with fresh blueberry",
               true,
               3.49);
            listMenu.Add(item);
            item = new MenuItem(
               "Waffles",
               "Waffles, with your choice of blueberries or strawberries",
               true,
               3.59);
            listMenu.Add(item);
        }

        public void AddItem(string name, string description, bool isVegetarian, double price)
        {
            MenuItem item = new MenuItem(name, description, isVegetarian, price);
            listMenu.Add(item);
        }
        public List<MenuItem> GetMenu()
        {
            return listMenu;
        }

        public Iterator CreateIterator()
        {
            return new PancakeHouseIterator(listMenu);
        }
    }

迭代器

interface Iterator
    {
        bool HaveNext();
        object Next();
    }

    class DinerMenuIterator : Iterator
    {
        MenuItem[] items;
        int position = 0;
        public DinerMenuIterator(MenuItem[] items)
        {
            this.items = items;
        }

        public bool HaveNext()
        {
            if (position >= items.Length || items[position] == null)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public object Next()
        {

            MenuItem item = items[position];
            position++;
            return item;
        }
    }

    class PancakeHouseIterator : Iterator
    {
        List<MenuItem> items;
        int position = 0;
        public PancakeHouseIterator(List<MenuItem> items)
        {
            this.items = items;
        }

        public bool HaveNext()
        {
            if (position >= items.Count)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        public object Next()
        {

            MenuItem item = items[position];
            position++;
            return item;
        }
    }

Waitress，服务员，相当于迭代器的使用者

class Waitress
    {
        DinerMenu dinerMenu;
        PancakeHouseMenu pancakeMenu;
        public Waitress(DinerMenu dinerMenu, PancakeHouseMenu pancakeMenu)
        {
            this.dinerMenu = dinerMenu;
            this.pancakeMenu = pancakeMenu;
        }
        public void PrintMenu()
        {
            Iterator dinerIterator = dinerMenu.CreateIterator();
            Iterator pancakeIterator = pancakeMenu.CreateIterator();
            Console.WriteLine("Diner@@@@@@@");
            PrineMenu(dinerIterator);
            Console.WriteLine("Pancake@@@@@@");
            PrineMenu(pancakeIterator);
        }

        private void PrineMenu(Iterator iterator)
        {
            while (iterator.HaveNext())
            {
                MenuItem item = (MenuItem)iterator.Next();
                Console.WriteLine(string.Format("{0} {1} {2}",item.Name,item.Description,item.Price));
            }
        }
    }

测试代码

class Program
    {
        static void Main(string[] args)
        {
            DinerMenu dinerMenu = new DinerMenu();
            PancakeHouseMenu pancakeMenu = new PancakeHouseMenu();
            Waitress waitress = new Waitress(dinerMenu, pancakeMenu);
            waitress.PrintMenu();
            Console.ReadKey();
        }
    }

单一职责原则：一个类应该只有一个引起变化的原因。

比如前文中的菜单，使用迭代器之前，菜单既要负责存储项目，又要负责展示，每次给菜单新增内容时都要都是修改这两方面的功能，造成了维护上的不便，而维护上的不便有可能带来逻辑上的混乱进而引发bug。可见，单一职责原则是很有指导意义的。