C#学习笔记整理-迭代器模式介绍-C#/.NET开发

下面小编就为大家分享一篇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 = 0;
 //将现在的数据组传输进来
 public ConcreteIterator(ConcreteAggregate aggregate)
 {
 this.aggregate = aggregate;
 }
 public override object CurrentItem()
 {
 return aggregate[current];
 }
 public override object First()
 {
 return aggregate[0];
 }
 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 = 0;
 //传输数据进来
 public ConcreteIteratorDesc(ConcreteAggregate aggregate)
 {
 this.aggregate = aggregate;
 current = aggregate.Count - 1;
 }
 public override object CurrentItem()
 {
 return aggregate[current];
 }
 public override object First()
 {
 return aggregate[aggregate.Count - 1];
 }
 public override bool IsDone()
 {
 return current < 0 ? true:false;
 }
 public override object Next()
 {
 object obj = null;
 current--;
 if (current >= 0)
 {
  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[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("{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