迭代器模式（Iterator Pattern）

 迭代器模式：让客户遍历你的对象而又无法窥视你存储对象的方式

场景：又一个早餐菜单和一个午餐菜单，使用迭代器模式将两个菜单打印出来。

//菜单创建迭代器的接口

    //类似工厂模式，子类需要实现创建枚举对象的方法
    public interface  Menu
    {
         IEnumerator createIterator();
    }

//菜单子项

    public class MenuItem
    {
        string name;
        string description;
        bool vegetarian;
        double price;

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

        public string getName()
        {
            return name;
        }

        public string getDescription()
        {
            return description;
        }

        public double getPrice()
        {
            return price;
        }

        public bool isVegetarian()
        {
            return vegetarian;
        }
    }

    public class PancakeHouseMenu :Menu
    {
        List<MenuItem> menuItems;
        public PancakeHouseMenu()
        {
            menuItems = new List<MenuItem>();

            addItem("K&B's薄煎饼早餐", "薄煎饼、氢弹、吐司", true, 2.99);

            addItem("薄煎饼早餐例餐", "薄煎饼带煎蛋、香肠", false, 2.99);

            addItem("蓝莓薄煎饼","薄煎饼、新鲜蓝莓、蓝莓糖浆",true,3.49);

            addItem("松饼", "松饼，可以选择蓝莓或草莓", true, 3.59);
        }

        public void addItem(string name, string description, bool vegetarian, double price)
        {
            MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
            menuItems.Add(menuItem);
        }

        public List<MenuItem> getMenuItems()
        {
            return menuItems;
        }
        //早餐菜单在LIST中，List本身支持获取枚举对象
        public IEnumerator createIterator()
        {
            return menuItems.GetEnumerator();
        }
    }

    public class DinerMenu : Menu, IEnumerator
    {
        const int MAX_ITEMS = 4;
        int numberOfItems = 0;
        MenuItem[] menuItems;
        int position = -1;

        public DinerMenu()
        {
            menuItems = new MenuItem[MAX_ITEMS];

            addItem("素食BLT", "(煎)培根、生菜&西红柿放在麦皮面包上",true,2.99);

            addItem("BLT", "培根、生菜&西红柿", true, 2.99);


        }

        public void addItem(string name, string description, bool vegetarian, double price)
        {
            MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
            if (numberOfItems >= MAX_ITEMS)
            {
                Console.WriteLine("对不起，菜单已经满了，不允许增加菜单了！");
            }
            else
            {
                menuItems[numberOfItems] = menuItem;
                numberOfItems++;
            }
        }

        public MenuItem[] getMenuItems()
        {
            return menuItems;
        }

        public object Current
        {
            get 
            {
                if (position < numberOfItems)
                    return menuItems[position];
                else
                    return null;
            }
        }

        public bool MoveNext()
        {
            position++;
            if (position < numberOfItems)
            {
                return true;
            }
            else
            {
                return false;
            }
            
        }

        public void Reset()
        {
            position = 0;
        }
        //午餐继承并实现了IEnumerator的接口，自身便包含了枚举对象
        public IEnumerator createIterator()
        {
            return this;
        }


    }

    public class Waitress
    {
        Menu pancakeHouseMenu;
        Menu dinerMenu;

        public Waitress(Menu pancakeHouseMenu, Menu dinerMenu)
        {
            this.pancakeHouseMenu = pancakeHouseMenu;
            this.dinerMenu = dinerMenu;
        }

        public void printMenu()
        {
            IEnumerator pancakeIterator = pancakeHouseMenu.createIterator();
            IEnumerator dinerIterator = dinerMenu.createIterator();
            Console.WriteLine("MENU\n----\nBREAKFAST");
            printMenu(pancakeIterator);
            Console.WriteLine("\nLUNCH");
            printMenu(dinerIterator);
        }
        //利用C#对枚举的支持进行遍历
        private void printMenu(IEnumerator iEnumerator)
        {
            while (iEnumerator.MoveNext())
            {
                if (iEnumerator.Current != null)
                {
                    MenuItem menuItem = (MenuItem)iEnumerator.Current;
                    Console.Write(menuItem.getName() + ", ");
                    Console.Write(menuItem.getPrice().ToString() + " -- ");
                    Console.WriteLine(menuItem.getDescription());
                }
                else
                {
                    break;
                }

            }
        }
    }

        static void Main(string[] args)
        {
            Menu pancakeHouseMenu = new PancakeHouseMenu();
            Menu dinerMenu = new DinerMenu();
            Waitress waitress = new Waitress(pancakeHouseMenu, dinerMenu);
            waitress.printMenu();
            Console.ReadLine();
        }

总结：

1.提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

2.把游走的任务放在迭代器上，而不是聚合上。这样简化了聚合的接口和实现，也让责任各得其所。

扩展：

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