迭代器模式（19）

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

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

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

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

    //迭代器抽象类
    abstract class Iterator
    {
        //得到开始对象；得到下一个对象；判断是否到结尾；得到当前对象
        public abstract object First();
        public abstract object Next();
        public abstract bool IsDone();
        public abstract object CurrentItem();
    }
    //聚集抽象类
    abstract class Aggregate
    {
        //创建迭代器
        public abstract Iterator CreateIterator();
    }
    //具体的迭代器类，继承Iterator
    class ConcreteIterator : Iterator
    {

        private ConcreteAggregate aggregage;
        private int current = 0;
        //初始化时将具体的聚集对象传入
        public ConcreteIterator(ConcreteAggregate aggregage)
        {
            this.aggregage = aggregage;
        }
        //得到聚集的第一个对象
        public override object First()
        {
            return aggregage[0];
        }
        //得到聚集的下一个对象
        public override object Next()
        {
            object ret = null;
            current++;
            if (current < aggregage.Count)
            {
                ret = aggregage[current];
            }
            return ret;
        }
        //判断当前是否遍历到结尾，到结尾返回true
        public override bool IsDone()
        {
            return current >= aggregage.Count ? true : false;
        }
        //返回当前的聚集对象
        public override object CurrentItem()
        {
            return aggregage[current];
        }
    }
    /// <summary>
    /// 具体的聚集类
    /// </summary>
    class ConcreteAggregate : Aggregate
    {
        //声明一个IList泛型变量，用于存放聚合对象，用ArrayList同样可以实现
        private IList<object> item = new List<object>();
        public override Iterator CreateIterator()
        {
            return new ConcreteIterator(this);
        }
        //返回聚集总个数
        public int Count
        {
            get { return item.Count; }
        }
        //声明一个索引器
        public object this[int index]
        {
            get { return item[index]; }
            set { item.Insert(index, value); }
        }
    }

客户端：

        public static void Main()
        {
            //聚集对象
            ConcreteAggregate a = new ConcreteAggregate();
            a[0] = "a";
            a[1] = "b";
            a[2] = "c";
            a[3] = "d";
            a[4] = "e";
            a[5] = "f";
            //迭代器
            Iterator i = new ConcreteIterator(a);
            object item = i.First();
            while (!i.IsDone())
            {
                Console.WriteLine($"{i.CurrentItem()}");
                i.Next(); //下一个
            }
            Console.ReadKey();
        }

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

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

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

---

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