迭代器——对象行为模式

深碍√TFBOYSˉ_ 2022-08-04 11:50 134阅读 0赞

# 意图 #

又叫做游标（Cursor）模式。提供一种方法访问一个容器（container）对象中各个元素，而又不需暴露该对象的内部细节。

--------------------

# 适用性 #

1.  访问一个聚合对象的内容而无需暴露它的内部表示；
2.  支持对聚合对象的多种遍历（从前到后，从后到前）；
3.  为遍历不同的聚合结构提供一个统一的接口，即支持多态迭代。

--------------------

# 结构图 #

![这里写图片描述][20150825153713617]

## 角色 ##

Iterator：定义迭代器访问和遍历元素的接口；  
ConcreteIterator：实现具体的迭代器；  
Aggregate：定义的容器，创建相应迭代器对象的接口；  
ConcreteAggregate：具体的容器实现创建相应迭代器的接口，该操作返回ConcreteIterator的一个适当的实例。

--------------------

# 实现 #

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Iterator
    {
        /*Iterator迭代器抽象类*/
        abstract  class Iterator
        {
            public abstract object First();
            public abstract object Next();
            public abstract object CurrentItem();
            public abstract bool IsDone();
        }
        /*Aggregate聚集抽象类*/
        abstract class Aggregate
        {
            public abstract Iterator createIterator();
        }
    
        class ConcreteIterator : Iterator
        {
    
            // 定义了一个具体聚集对象 
            private ConcreteAggregate aggregate;
    
            private int current = 0;
    
            // 初始化对象将具体聚集类传入
            public ConcreteIterator(ConcreteAggregate aggregate)
            {
                this.aggregate = aggregate;
            }
    
            // 第一个对象
            public override object First()
            {
                return aggregate[0];
            }
    
            // 得到聚集的下一对象
            public override object Next()
            {
                object ret = null;
                current++;
                if (current < aggregate.Count)
                {
                    ret = aggregate[current];
                }
                return ret;
            }
    
            // 是否到结尾 
            public override bool IsDone()
            {
                return current >= aggregate.Count ? true : false;
            }
    
            // 返回当前聚集对象
            public override object CurrentItem()
            {
                return aggregate[current];
            }
        }
    
        class ConcreteAggregate : Aggregate
        {
            private IList<object> items = new List<object>();
    
            public override Iterator createIterator()
            {
                return new ConcreteIterator(this);
            }
    
            // 返回聚集总个数
            public int Count
            {
                get { return items.Count; }
            }
    
            // 声明一个索引器
            public object this[int index]
            {
                get { return items[index]; }
                set { items.Insert(index, value); }
            }
        }
    }

## 客户端 ##

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace Iterator { 
        class Program { 
            static void Main(string[] args)
            {
                ConcreteAggregate ca = new ConcreteAggregate();
                ca[0] = "大鸟";
                ca[1] = "小菜";
                ca[2] = "行李";
                ca[3] = "老外";
                ca[4] = "公交内部员工";
                ca[5] = "小偷";
    
                Iterator i = new ConcreteIterator(ca);
                object obj = i.First();
                while (!i.IsDone())
                {
                    Console.WriteLine("{0} 请买车票！",i.CurrentItem());
                    i.Next();
                }
                Console.Read();
            }
        }
    }

--------------------

# 总结 #

迭代器模式（Iterator）就是分离了聚合对象的遍历行为，抽象出一个迭代器来负责这样既可以做到不暴露集合的内部结构，又可让外部代码透明的访问集合内部数据。

[20150825153713617]: /images/20220731/f7e4a1f82f88403e932c0986b39cb9d5.png