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

时间:2024-01-20 16:45:09

什么是迭代器模式?

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

何时使用迭代器模式?

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

迭代器模式的组成

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

  ConcreteAggregate():保存聚合对象。

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

迭代器模式具体实现

迭代器模式的结构

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

迭代器模式的实现:

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

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

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