c#设计模式-行为型模式之迭代器模式

桃扇骨 2024-04-23 20:20 76阅读 0赞

## ?简介 ##

提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。

迭代器模式主要包含以下角色：

1.  抽象聚合（Aggregate）角色：定义存储、添加、删除聚合元素以及创建迭代器对象的接口。 
2.  具体聚合（ConcreteAggregate）角色：实现抽象聚合类，返回一个具体迭代器的实例。 
3.  抽象迭代器（Iterator）角色：定义访问和遍历聚合元素的接口，通常包含 hasNext()、next() 等方法。 
4.  具体迭代器（Concretelterator）角色：实现抽象迭代器接口中所定义的方法，完成对聚合对象的遍历，记录遍历的当前位置。

## ?案例 ##

?抽象迭代器（Iterator）角色

//定义迭代器接口
    public interface IIterator
    {
        bool HasNext();
        object Next();
    }

?抽象聚合（Aggregate）角色

//定义集合接口
    public interface IAggregate
    {
        IIterator GetIterator();
    }

?具体聚合（ConcreteAggregate）角色

在这个类中，有一个私有的只读的`List<string>`类型的字段`_items`，用于存储字符串类型的数据。

`GetIterator()`方法返回一个`IIterator`类型的迭代器，这个迭代器是用于遍历`_items`中的数据。

`Count`属性返回`_items`中的元素数量。

索引器`this[int index]`用于获取或设置`_items`中指定索引位置的元素。

public class ConcreteAggregate : IAggregate
    {
        private readonly List<string> _items = new List<string>();
    
        public IIterator GetIterator()
        {
            return new ConcreteIterator(this);
        }
    
        public int Count
        {
            get { return _items.Count; }
        }
    
        public string this[int index]
        {
            get { return _items[index]; }
            set { _items.Insert(index, value); }
        }
    }

?具体迭代器（Concretelterator）角色

*  `_aggregate`是一个`ConcreteAggregate`类型的私有只读字段，它表示要遍历的聚合对象。
 *  `_current`是一个私有字段，表示当前遍历到的位置。
 *  `ConcreteIterator(ConcreteAggregate aggregate)`是一个构造函数，用于创建`ConcreteIterator`对象。这个构造函数需要一个`ConcreteAggregate`对象作为参数，但是这段代码中并没有显示这个构造函数的实现。
 *  `HasNext()`方法用于判断是否还有下一个元素。如果当前位置`_current`小于聚合对象的元素数量，那么就返回`true`，表示还有下一个元素；否则返回`false`。
 *  `Next()`方法用于获取下一个元素。它返回当前位置`_current`的元素，并将`_current`加1，以便下次调用`Next()`时能返回下一个元素。

public class ConcreteIterator : IIterator
    {
        private readonly ConcreteAggregate _aggregate;
        private int _current = 0;
    
        public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this._aggregate = aggregate;
        }
    
        public bool HasNext()
        {
            return _current < _aggregate.Count;
        }
    
        public object Next()
        {
            return _aggregate[_current++];
        }
    }

?测试类

public static void Main(string[] args)
        {
            ConcreteAggregate a = new ConcreteAggregate();
            a[0] = "Item A";
            a[1] = "Item B";
            a[2] = "Item C";
            a[3] = "Item D";
    
            IIterator i = a.GetIterator();
    
            while (i.HasNext())
            {
                Console.WriteLine(i.Next());
            }
        }

?运行结果！

![ef8ac38437ea422092ab093d603ce4f2.png][]

## ?优缺点 ##

**优点：**

1.  它支持以不同的方式遍历一个聚合对象，在同一个聚合对象上可以定义多种遍历方式。在迭代器模式中只需要用一个不同的迭代器来替换原有迭代器即可改变遍历算法，我们也可以自己定义迭代器 的子类以支持新的遍历方式。 
2.  迭代器简化了聚合类。由于引入了迭代器，在原有的聚合对象中不需要再自行提供数据遍历等方法，这样可以简化聚合类的设计。 
3.  在迭代器模式中，由于引入了抽象层，增加新的聚合类和迭代器类都很方便，无须修改原有代码，满足 “开闭原则” 的要求。

**缺点：**

1.  增加了类的个数，这在一定程度上增加了系统的复杂性。

**使用场景**

1.  当需要为聚合对象提供多种遍历方式时。 
2.  当需要为遍历不同的聚合结构提供一个统一的接口时。 
3.  当访问一个聚合对象的内容而无须暴露其内部细节的表示时。

[ef8ac38437ea422092ab093d603ce4f2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/cb521666dc644737aa70a20e968faa68.png