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

来源：cnblogs　　作者：酷学大叔　　时间：2019/10/8 11:04:05　　对本文有异议

迭代器模式（Iterator）:

　　迭代器模式允许你访问一个数据项序列中的所有元素，而无须关心序列是什么类型（数组、链表、列表或任何其他类型）。它能有效地构建一个数据管道，经过一系列不同的转换或过滤后再从管道的另一端出来。迭代器模式就是提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示。

迭代器模式的角色：

　　1）抽象迭代器（Iterator）：接口声明了遍历集合所需的操作（获取下一个元素、获取当前位置和重新开始迭代等）。

　　2）具体迭代器（ConcreteIterator）：实现遍历集合的一种特定算法。迭代器对象必须跟踪自身遍历的进度。这使得多个迭代器可以相互独立地遍历同一个集合。

　　3）抽象聚合（Aggregate）：接口声明一个或多个方法来获取与集合兼容的迭代器。返回方法的类型必须被声明为迭代器接口。

　　4）具体聚合（ConcreteAggregate）：会在客户端请求迭代器时返回一个特定的具体迭代器类实体。

　　5）客户端（Client）：通过集合和迭代器的接口与两者进行交互。这样一来客户端无需与具体类进行耦合，允许同一客户端代码使用各种不同的集合和迭代器。

示例：

　　先假设有两家餐厅，主营业务不同，一家是早餐店，一家是晚餐店。

  1 /// <summary>
  2 /// 菜单明细项
  3 /// </summary>
  4 public class MenuItem
  5 {
  6     private string name;
  7     private string description;
  8     private bool vegetarin;
  9     private double price;
 10 
 11     public MenuItem(string name, string description, bool vegetarin, double price)
 12     {
 13         this.name = name;
 14         this.description = description;
 15         this.vegetarin = vegetarin;
 16         this.price = price;
 17     }
 18 
 19     public string GetName()
 20     {
 21         return this.name;
 22     }
 23 
 24     public double GetPrice()
 25     {
 26         return price;
 27     }
 28 
 29     public bool IsVegetarian()
 30     {
 31         return vegetarin;
 32     }
 33 
 34     public string GetDescription()
 35     {
 36         return description;
 37     }
 38 }
 39 
 40 /// <summary>
 41 /// 早餐菜单
 42 /// </summary>
 43 public class BreakfastMenu
 44 {
 45     private List<MenuItem> menuItems;
 46 
 47     public BreakfastMenu()
 48     {
 49         menuItems = new List<MenuItem>();
 50         AddItem("牛奶", "牛奶description", false, 3.0);
 51         AddItem("油条", "油条description", false, 1.0);
 52         AddItem("馒头", "馒头description", true, 1.0);
 53         AddItem("豆浆", "DoujiangDescription", true, 1.5);
 54     }
 55 
 56     public void AddItem(string name, string description, bool vegetarian, double price)
 57     {
 58         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
 59         menuItems.Add(menuItem);
 60     }
 61 
 62     public List<MenuItem> GetMenuItems()
 63     {
 64         return menuItems;
 65     }
 66 }
 67 
 68 /// <summary>
 69 /// 晚餐菜单
 70 /// </summary>
 71 public class DinnerMenu
 72 {
 73     private static readonly int Max_ITEMS = 6;
 74     private int numberOfItems = 0;
 75     private MenuItem[] menuItems;
 76 
 77     public DinnerMenu()
 78     {
 79         menuItems = new MenuItem[Max_ITEMS];
 80         AddItem("香菇豆腐饭", "香菇豆腐", false, 10.5);
 81         AddItem("蛋炒饭", "哈哈", false, 8.5);
 82         AddItem("鱼香肉丝", "你猜", true, 15.5);
 83     }
 84 
 85     public void AddItem(string name, string description, bool vegetarian, double price)
 86     {
 87         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
 88         if (numberOfItems > Max_ITEMS)
 89         {
 90             Console.WriteLine("菜单已满");
 91         }
 92         else
 93         {
 94             menuItems[numberOfItems] = menuItem;
 95             numberOfItems++;
 96         }
 97     }
 98 
 99     public MenuItem[] GetMenuItems()
100     {
101         return menuItems;
102     }
103 }

　　现在两家合并了，服务员那菜单的时候就要拿两份菜单。

 1 public static void Main(string[] args)
 2 {
 3     BreakfastMenu breakfastMenu = new BreakfastMenu();
 4     List<MenuItem> breakfastItems = breakfastMenu.GetMenuItems();
 5 
 6     DinnerMenu dinerMenu = new DinnerMenu();
 7     MenuItem[] lunchItems = dinerMenu.GetMenuItems();
 8 
 9     for (int i = 0; i < breakfastItems.Count; i++)
10     {
11         MenuItem menuItem = breakfastItems[i] as MenuItem;
12         Console.WriteLine(menuItem.GetName() + " " + menuItem.GetPrice().ToString() + " " + menuItem.GetDescription().ToString());
13     }
14 
15     for (int j = 0; j < lunchItems.Length; j++)
16     {
17         MenuItem lunchItem = lunchItems[j];
18         if (lunchItem != null)
19         {
20             Console.WriteLine(lunchItem.GetName() + " " + lunchItem.GetPrice().ToString() + " " + lunchItem.GetDescription().ToString());
21         }
22     }
23 }

　　我们发现，由于两份菜单数据结构的不同，我们不得不重写多余的代码，显得很臃肿。我们会想：能不能有一个东西能够让我们不需要知道菜单的数据结构，直接就可以获取其内部元素呢？答案是肯定的，这就是我们本节所说的迭代器模式。

　　先定义一个接口迭代器并实现晚餐菜单迭代器和晚餐菜单迭代器。

 1 /// <summary>
 2 /// 接口迭代器
 3 /// </summary>
 4 public interface Iterator
 5 {
 6     /// <summary>
 7     /// 用来判断下一个元素是否为空
 8     /// </summary>
 9     /// <returns></returns>
10     bool HasNext();
11 
12     /// <summary>
13     /// 用来获取当前元素
14     /// </summary>
15     /// <returns></returns>
16     object Next();
17 }
18 
19 /// <summary>
20 /// 早餐菜单迭代器
21 /// </summary>
22 public class BreakfastIterator : Iterator
23 {
24     private List<MenuItem> items;
25     private int position = 0;
26 
27     public BreakfastIterator(List<MenuItem> items)
28     {
29         this.items = items;
30     }
31 
32     public bool HasNext()
33     {
34         return position <= items.Count - 1 && items[position] != null;
35     }
36 
37     public object Next()
38     {
39         MenuItem item = items[position];
40         position++;
41         return item;
42     }
43 }
44 
45 /// <summary>
46 /// 晚餐菜单迭代器
47 /// </summary>
48 public class DinnerIterator : Iterator
49 {
50     private MenuItem[] items;
51     private int position = 0;
52 
53     public DinnerIterator(MenuItem[] items)
54     {
55         this.items = items;
56     }
57 
58     public bool HasNext()
59     {
60         return position <= items.Length && items[position] != null;
61     }
62 
63     public object Next()
64     {
65         MenuItem item = items[position];
66         position++;
67         return item;
68     }
69 }

　　修改菜单。

 1 /// <summary>
 2 /// 抽象聚合对象，用于创建一个迭代器对象
 3 /// </summary>
 4 public interface IMenu
 5 {
 6     Iterator CreateIterator();
 7 }
 8 
 9 /// <summary>
10 /// 早餐菜单
11 /// </summary>
12 public class BreakfastMenu : IMenu
13 
14 {
15     private List<MenuItem> menuItems;
16 
17     public BreakfastMenu()
18     {
19         menuItems = new List<MenuItem>();
20         AddItem("牛奶", "牛奶description", false, 3.0);
21         AddItem("油条", "油条description", false, 1.0);
22         AddItem("馒头", "馒头description", true, 1.0);
23         AddItem("豆浆", "DoujiangDescription", true, 1.5);
24     }
25 
26     public void AddItem(string name, string description, bool vegetarian, double price)
27     {
28         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
29         menuItems.Add(menuItem);
30     }
31 
32     //public List<MenuItem> GetMenuItems()
33     //{
34     //    return menuItems;
35     //}
36 
37     public Iterator CreateIterator()
38     {
39         return new BreakfastIterator(menuItems);
40     }
41 }
42 
43 /// <summary>
44 /// 晚餐菜单
45 /// </summary>
46 public class DinnerMenu : IMenu
47 
48 {
49     private static readonly int Max_ITEMS = 6;
50     private int numberOfItems = 0;
51     private MenuItem[] menuItems;
52 
53     public DinnerMenu()
54     {
55         menuItems = new MenuItem[Max_ITEMS];
56         AddItem("香菇豆腐饭", "香菇豆腐", false, 10.5);
57         AddItem("蛋炒饭", "哈哈", false, 8.5);
58         AddItem("鱼香肉丝", "你猜", true, 15.5);
59     }
60 
61     public void AddItem(string name, string description, bool vegetarian, double price)
62     {
63         MenuItem menuItem = new MenuItem(name, description, vegetarian, price);
64         if (numberOfItems > Max_ITEMS)
65         {
66             Console.WriteLine("菜单已满");
67         }
68         else
69         {
70             menuItems[numberOfItems] = menuItem;
71             numberOfItems++;
72         }
73     }
74 
75     //public MenuItem[] GetMenuItems()
76     //{
77     //    return menuItems;
78     //}
79 
80     public Iterator CreateIterator()
81     {
82         return new DinnerIterator(menuItems);
83     }
84 }

　　这个时候，两份餐单的输出是这样的。

 1 public static void Main(string[] args)
 2 {
 3     IMenu breakfastMenu = new BreakfastMenu();
 4     IMenu dinnerMenu = new DinnerMenu();
 5     breakfastMenu.CreateIterator();
 6     Iterator dinnerIterator = dinnerMenu.CreateIterator();
 7     Iterator breakfastIterator = breakfastMenu.CreateIterator();
 8 
 9     Print(breakfastIterator);
10     Print(dinnerIterator);
11 
12     static void Print(Iterator iterator)
13     {
14         while (iterator.HasNext())
15         {
16             MenuItem menuItem = (MenuItem)iterator.Next();
17             Console.WriteLine(menuItem.GetName() + " " + menuItem.GetPrice().ToString() + " " + menuItem.GetDescription().ToString());
18         }
19     }
20 }