定义

提供一种方法 顺序访问一个聚集对象的中各个元素，而又不暴露该对象的内部表示

使用场景

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

代码实现

//迭代器 抽象
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(); //创建迭代器
}

//迭代器 具体
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;
    }
    
    public override object CurrentItem()
    {
        return aggregate[current];
    }

}

//聚集 具体
class ConcreteAggregate: Aggregate
{
    private IList<object> items = new List<object>();

    public override Iterator CreateIterator()
    {
         return new ConcreateIterator(this);
    }
    
    public int Count { get { return items.Count; } }
    
    public object this[int index]
    {
         get { return items[index]; }
         set { items.Insert(index, value); }
    }

}


void Main()
{
   ConcreateAggregate a = new ConcreteAggregate();
   a[0] = "张三";
   a[1] = "李四";
   a[2] = "王五";
   a[3] = "赵六";

    Iterator iterator = a.CreateIterator();
    //object item = iterator.First();
    while (!iterator.IsDone())
    {
         Console.WriteLine(iterator.CurrentItem());
         iterator.Next();
     }

}

优点与缺点

1. 它支持以不同的方式遍历一个聚合对象。
2. 迭代器简化了聚合类。
3. 在同一个聚合上可以有多个遍历。
4. 在迭代器模式中，增加新的聚合类和迭代器类都很方便，无须修改原有代码。
5. 由于迭代器模式将存储数据和遍历数据的职责分离，增加新的聚合类需要对应增加新的迭代器类，类的个数成对增加，这在一定程度上增加了系统的复杂性