创建型模式-单件模式

using System;

using System.Text;

using System.Collections.Generic;

using System.Collections;

namespace 迭代模式

{



    /*

     * 迭代模式意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。

     * 

     * 迭代模式实现要点：1、迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。

     *                   2、迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行

     *                   3、迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，有可能导致问题。

     *                   

     * 迭代模式优点：1、访问一个聚合对象的内容而无需暴露它的内部表示。

     *               2、支持对聚合对象的多种遍历。 

     *               3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。

     *               

     * 迭代模式缺点：1、通过增加具体的接口，有可能增加代码的阅读难度

     * 

     * 迭代模式适用场景：1、

     */



    /// <summary>

    /// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。

    /// </summary>

    public abstract class Aggregate

    {

        public abstract Iterator CreateIterator();

    }

    /// <summary>

    /// 抽象迭代方法

    /// </summary>

    public abstract class Iterator

    {

        public abstract object First();



        public abstract object Next();



        public abstract bool IsDone();



        public abstract object CurrentItem();

    }



    /// <summary>

    /// 具体实现迭代类

    /// </summary>

    public class ConcreteAggregate : Aggregate

    {

        private ArrayList _items=new ArrayList();





        public int Count

        {

            get { return this._items.Count; }

        }

        public object this[int index]

        {

            get { return this._items[index]; }

            set { this._items[index] = value; }

        }



        /// <summary>

        /// 创建迭对象

        /// </summary>

        /// <returns></returns>

        public override Iterator CreateIterator()

        {

            return new ConcreteIterator(this);

        }

    }



    /// <summary>

    /// 具体迭代类

    /// </summary>

    public class ConcreteIterator : Iterator

    {

        private ConcreteAggregate aggregate;

        private int _current = 0;



        /// <summary>

        /// 将聚合类和具体迭代关联

        /// </summary>

        /// <param name="aggregate"></param>

        public ConcreteIterator(ConcreteAggregate aggregate)

        {

            this.aggregate = aggregate;

        }

    

        //具体迭代方法

        public override object First()

        {

            return aggregate[0];   

        }



        public override object Next()

        {

            object ret = null;

            if (_current<aggregate.Count-1)

            {

                ret = aggregate[_current++];

            }

            return ret;

        }



        public override bool IsDone()

        {

            return _current >= aggregate.Count;

        }



        public override object CurrentItem()

        {

            return aggregate[_current];

        }



    }



    public class AppCient

    {

        public static void Main(string[] args)

        {

            ConcreteAggregate ca = new ConcreteAggregate();

            ca[0] = "Item0";

            ca[1] = "Item1";

            ca[2] = "Item2";

            ca[3] = "Item3";

            ConcreteIterator ci=new ConcreteIterator(ca);



            object current = ci.First();

            //开始迭代



            while (current!=null)

            {

                Console.Write(current);

                current = ci.Next();

                

            }

        }

        

    }

}