迭代器模式（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 : Iterator23 {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 : Iterator49 {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 : IMenu13 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 : IMenu47 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 else69 {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 }
迭代器模式适用性：
1）当集合背后为复杂的数据结构，且你希望对客户端隐藏其复杂性时（出于使用便利性或安全性的考虑），可以使用迭代器。
2）可以减少程序中重复的遍历代码。
3）如果你希望代码能够遍历不同的甚至是无法预知的数据结构，可以使用迭代器。
迭代器模式的优缺点：
优点：
1）它支持以不同的方式遍历一个聚合对象。
2）迭代器简化了聚合类。
3）在同一个聚合上可以有多个遍历。
4）在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。符合OCP原则。
缺点：由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性。
联系客服
