設計模式學習筆記-迭代器模式

概述：                                                                                                      

迭代器模式(Iterator)：提供一種方法順序一個彙總對象中各個元素，而又不暴露該對象內部表示。

實用場合：                                                                                                 

1.訪問一個彙總對象的內容而無需暴露它的內部表示。

2.支援對彙總對象的多種遍曆。

3.為遍曆不同的彙總結構提供一個統一的介面(即，多態迭代)。

類圖：                                                                                                       

代碼結構樣本：                                                                                            

1.迭代器抽象類別

    /// <summary>
/// 迭代器抽象類別
/// 用於定義得到的開始對象，下一個對象，是否到結尾，當前對象方法，統一介面
/// </summary>
    abstract class Iterator
    {
public abstract object First();

public abstract object Next();

public abstract bool IsDone();

public abstract object CurrentItem();
    }

2.實現迭代器類

    class ConcreteIterator:Iterator
    {
/// <summary>
/// 定義了一個具體聚集對象
/// </summary>
        private ConcreteAggregate aggregate;

private int current = 0;
/// <summary>
/// 初始化對象將具體聚集類傳入
/// </summary>
/// <param name="aggregate"></param>
        public ConcreteIterator(ConcreteAggregate aggregate) 
        {
this.aggregate = aggregate;
        }
/// <summary>
/// 第一個對象
/// </summary>
/// <returns></returns>
        public override object First()
        {
return aggregate[0];
        }
/// <summary>
/// 得到聚集的下一對象
/// </summary>
/// <returns></returns>
        public override object Next()
        {
object ret = null;
            current++;
if(current<aggregate.Count)
            {
                ret = aggregate[current];
            }
return ret;
        }
/// <summary>
/// 是否到結尾
/// </summary>
/// <returns></returns>
        public override bool IsDone()
        {
return current >= aggregate.Count ? true : false;
        }
/// <summary>
/// 返回當前聚集對象
/// </summary>
/// <returns></returns>
        public override object CurrentItem()
        {
return aggregate[current];
        }
    }

3.聚集抽象類別

    /// <summary>
/// 聚集抽象類別
/// </summary>
    abstract class Aggregate
    {
/// <summary>
/// 建立迭代器
/// </summary>
/// <returns></returns>
        public abstract Iterator CreateIterator();
    }

4.聚集實作類別

    class ConcreteAggregate:Aggregate
    {
private IList<object> items = new List<object>();

public override Iterator CreateIterator()
        {
return new ConcreteIterator(this);
        }
/// <summary>
/// 返回聚集總個數
/// </summary>
        public int Count 
        {
get { return items.Count; }
        }
/// <summary>
/// 聲明一個索引器
/// </summary>
/// <param name="index"></param>
/// <returns></returns>
        public object this[int index] 
        {
get { return items[index]; }
set { items.Insert(index, value); }
        }
    }

5.用戶端實現

        /// <summary>
/// 測試迭代器模式
/// </summary>
        static void TestIterator() 
        {
//聚集對象
            ConcreteAggregate a = new ConcreteAggregate();

            a[0] = "張三";
            a[1] = "李四"; 
            a[2] = "葉鵬";
//聲明迭代器對象
            Iterator i = new ConcreteIterator(a);

object item = i.First();
while(!i.IsDone())
            {
                Console.WriteLine("{0}回家吃飯",i.CurrentItem());
                i.Next();
            }
            Console.Read();
        }

小結：                                                                                         

其實.net架構已經準備好了迭代器介面，只需要實現介面就行了

IEumerator 支援對非泛型集合的簡單迭代

上面的例子用一個foreach就可以實現了，但是迭代器這種思想如果明白就更好了