迭代器模式（19）

今天我们来讲一下迭代器模式。

什么叫迭代器模式呢？迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。

什么时候考虑用迭代器模式呢？当你需要访问一个聚焦对象，而且不管这些对象是什么都需要遍历的时候，你就应该考虑用迭代器模式。

好，下面我们看一下迭代器的基本代码：

 1     //迭代器抽象类
 2     abstract class Iterator
 3     {
 4         //得到开始对象；得到下一个对象；判断是否到结尾；得到当前对象
 5         public abstract object First();
 6         public abstract object Next();
 7         public abstract bool IsDone();
 8         public abstract object CurrentItem();
 9     }
10     //聚集抽象类
11     abstract class Aggregate
12     {
13         //创建迭代器
14         public abstract Iterator CreateIterator();
15     }
16     //具体的迭代器类，继承Iterator
17     class ConcreteIterator : Iterator
18     {
19 
20         private ConcreteAggregate aggregage;
21         private int current = 0;
22         //初始化时将具体的聚集对象传入
23         public ConcreteIterator(ConcreteAggregate aggregage)
24         {
25             this.aggregage = aggregage;
26         }
27         //得到聚集的第一个对象
28         public override object First()
29         {
30             return aggregage[0];
31         }
32         //得到聚集的下一个对象
33         public override object Next()
34         {
35             object ret = null;
36             current++;
37             if (current < aggregage.Count)
38             {
39                 ret = aggregage[current];
40             }
41             return ret;
42         }
43         //判断当前是否遍历到结尾，到结尾返回true
44         public override bool IsDone()
45         {
46             return current >= aggregage.Count ? true : false;
47         }
48         //返回当前的聚集对象
49         public override object CurrentItem()
50         {
51             return aggregage[current];
52         }
53     }
54     /// <summary>
55     /// 具体的聚集类
56     /// </summary>
57     class ConcreteAggregate : Aggregate
58     {
59         //声明一个IList泛型变量，用于存放聚合对象，用ArrayList同样可以实现
60         private IList<object> item = new List<object>();
61         public override Iterator CreateIterator()
62         {
63             return new ConcreteIterator(this);
64         }
65         //返回聚集总个数
66         public int Count
67         {
68             get { return item.Count; }
69         }
70         //声明一个索引器
71         public object this[int index]
72         {
73             get { return item[index]; }
74             set { item.Insert(index, value); }
75         }
76     }

客户端：

 1         public static void Main()
 2         {
 3             //聚集对象
 4             ConcreteAggregate a = new ConcreteAggregate();
 5             a[0] = "a";
 6             a[1] = "b";
 7             a[2] = "c";
 8             a[3] = "d";
 9             a[4] = "e";
10             a[5] = "f";
11             //迭代器
12             Iterator i = new ConcreteIterator(a);
13             object item = i.First();
14             while (!i.IsDone())
15             {
16                 Console.WriteLine($"{i.CurrentItem()}");
17                 i.Next(); //下一个
18             }
19             Console.ReadKey();
20         }

在.net实际的开发中，我们没有这么麻烦，因为.net框架已经为我们准备好了相关的接口了，我们只需要去实现就可以了。这个接口就是IEumerator，支持对非泛型聚合的简单迭代接口。我们可以看一下IEumerator这个接口，它要比我们刚才写的抽象类Iterator要简洁，但可实现的功能却一点也不少。另外这亮哥接口还有相应的泛型接口，可以去查一下MSDN。有了个这基础，我们再看一下熟悉的foreach in 就很简单了。原来foreach in 就是实现这两个接口来实际循环遍历。

迭代器模式就是分离了集合对象的遍历行为，抽象出一个迭代类来分离，这样即可以做到不暴露集合内部接口，又可以让外部代码透明的访问集合内部的数据。

好了，迭代器模式我们就讲到这里了，下一篇博文，我们讲 单例模式

---

本系列将持续更新，喜欢的小伙伴可以点一下关注和推荐，谢谢大家的支持

转载于:https://www.cnblogs.com/xiaomowang/p/6392515.html