C#学习笔记-迭代器模式

什么是迭代器模式？

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

何时使用迭代器模式？

　　当需要访问一个聚合对象，而且不管这些对象是什么都需要遍历的时候，需要考虑使用迭代器模式。

迭代器模式的组成

　　Iterator()：迭代器抽象类，用于定义得到开始对象，对到下一个对象，判断是否到结尾，当前对象等抽象方法，统一接口。

　　ConcreteAggregate()：保存聚合对象。

　　ConcreteIterator():继承于Iterator，实现具体如何对聚合对象的操作。

迭代器模式具体实现

迭代器模式的结构

　　

迭代器模式的实现：

Iterator：

 abstract class Iterator
 {
     public abstract object First();
     public abstract object Next();
     public abstract bool IsDone();
     public abstract object CurrentItem();
 } 

ConcreteIterator:

 //顺序遍历
 class ConcreteIterator : Iterator
 {
     private ConcreteAggregate aggregate;
     private int current = ;
     //将现在的数据组传输进来
     public ConcreteIterator(ConcreteAggregate aggregate)
     {
         this.aggregate = aggregate;
     }
     public override object CurrentItem()
     {
         return aggregate[current];
     }

     public override object First()
     {
         return aggregate[];
     }

     public override bool IsDone()
     {
         return current >= aggregate.Count ? true : false;
     }

     public override object Next()
     {
         object obj = null;
         current++;
         if (current < aggregate.Count)
         {
             obj = aggregate[current];
         }
         return obj;
     }
 }
 //逆序遍历
 class ConcreteIteratorDesc : Iterator
 {
     private ConcreteAggregate aggregate;
     private int current = ;
     //传输数据进来
     public ConcreteIteratorDesc(ConcreteAggregate aggregate)
     {
         this.aggregate = aggregate;
         current = aggregate.Count - ;
     }
     public override object CurrentItem()
     {
         return aggregate[current];
     }

     public override object First()
     {
         return aggregate[aggregate.Count - ];
     }

     public override bool IsDone()
     {
         return current <  ? true:false;
     }

     public override object Next()
     {
         object obj = null;
         current--;
         if (current >= )
         {
             obj = aggregate[current];
         }
         return obj;
     }
 } 

ConcreteAggregate：

 /// <summary>
 /// 创建迭代器
 /// 在这里看并没有什么具体的用处
 /// </summary>
 abstract class Aggregate
 {
     public abstract Iterator CreateIterator();
 }

 /// <summary>
 /// 作用是保存数据,保存的数据是一系列数据，所以用数组
 /// 然后传输数据给ConcreteIterator
 /// </summary>
 class ConcreteAggregate : Aggregate
 {
     //用于存放聚合对象
     private IList<object> items = new List<object>();
     public override Iterator CreateIterator()
     {
         return new ConcreteIterator(this);
     }
     //数组的长度，也就是ConcreteAggregate的属性
     public int Count { get { return items.Count; } }
     /// ConcreteAggregate现在是数组形式
     /// get获取当前的数据
     /// set将新来的数据插入到ConcreteAggregate中
     public object this[int index]
     {
         get { return items[index]; }
         set { items.Insert(index, value); }
     }
 } 

主函数调用：

 static void Main(string[] args)
 {
     ConcreteAggregate a = new ConcreteAggregate();
     a[] = "A";
     a[] = "B";
     a[] = "C";
     a[] = "D";
     a[] = "E";
     a[] = "F";

     Iterator i = new ConcreteIterator(a);
     object item = i.First();
     while (!i.IsDone())
     {
         Console.WriteLine("{0} buy ticket,please", i.CurrentItem());
         i.Next();
     }

     Iterator id = new ConcreteIteratorDesc(a);
     object itemdec = id.First();
     while (!id.IsDone())
     {
         Console.WriteLine("{0} buy ticket,please", id.CurrentItem());
         id.Next();
     }

     Console.Read();
 } 

.NET的迭代器实现

　　迭代器模式在我们现在的使用中其实没有那么麻烦，因为.NET框架已经准备好了相关的接口，只需要实现就好了。

 static void Main(string[] args)
 {
     IList<string> a = new List<string>();

     a.Add("A");
     a.Add("B");
     a.Add("C");
     a.Add("D");
     a.Add("E");
     a.Add("F");

     //看见遍历首先考虑foreach
     foreach (string item in a)
     {
         Console.WriteLine("{0} buy ticket,please", item);
     }
     //支持在泛型集合上进行简单迭代。
     IEnumerator<string> e = a.GetEnumerator();
     while (e.MoveNext())
     {
         Console.WriteLine("{0} buy ticket,please", e.Current);
     }

     Console.Read();
 } 

补充：IEnumerator

　　

备注：文中所有代码及知识点均来自于《大话设计模式》,本人属于边学边看边敲代码边总结的阶段。