行为型模式-迭代模式

using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{

    /*
     * 迭代模式意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
     * 
     * 迭代模式实现要点：1、迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
     *                   2、迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行
     *                   3、迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，有可能导致问题。
     *                   
     * 迭代模式优点：1、访问一个聚合对象的内容而无需暴露它的内部表示。
     *               2、支持对聚合对象的多种遍历。 
     *               3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
     *               
     * 迭代模式缺点：1、通过增加具体的接口，有可能增加代码的阅读难度
     * 
     * 迭代模式适用场景：1、
     */

    ///<summary>
    /// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
    ///</summary>
publicabstractclass Aggregate
    {
        publicabstract Iterator CreateIterator();
    }
    ///<summary>
    /// 抽象迭代方法
    ///</summary>
publicabstractclass Iterator
    {
        publicabstractobject First();

        publicabstractobject Next();

        publicabstractbool IsDone();

        publicabstractobject CurrentItem();
    }

    ///<summary>
    /// 具体实现迭代类
    ///</summary>
publicclass ConcreteAggregate : Aggregate
    {
        private ArrayList _items=new ArrayList();


        publicint Count
        {
            get { returnthis._items.Count; }
        }
        publicobjectthis[int index]
        {
            get { returnthis._items[index]; }
            set { this._items[index] = value; }
        }

        ///<summary>
        /// 创建迭对象
        ///</summary>
        ///<returns></returns>
publicoverride Iterator CreateIterator()
        {
            returnnew ConcreteIterator(this);
        }
    }

    ///<summary>
    /// 具体迭代类
    ///</summary>
publicclass ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate;
        privateint _current =0;

        ///<summary>
        /// 将聚合类和具体迭代关联
        ///</summary>
        ///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
    
        //具体迭代方法
publicoverrideobject First()
        {
            return aggregate[0];   
        }

        publicoverrideobject Next()
        {
            object ret =null;
            if (_current<aggregate.Count-1)
            {
                ret = aggregate[_current++];
            }
            return ret;
        }

        publicoverridebool IsDone()
        {
            return _current >= aggregate.Count;
        }

        publicoverrideobject CurrentItem()
        {
            return aggregate[_current];
        }

    }

    publicclass AppCient
    {
        publicstaticvoid 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();
                
            }
        }
        
    }
}

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();
               
            }
        }
       
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{

    /*
     * 迭代模式意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
     * 
     * 迭代模式实现要点：1、迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
     *                   2、迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行
     *                   3、迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，有可能导致问题。
     *                   
     * 迭代模式优点：1、访问一个聚合对象的内容而无需暴露它的内部表示。
     *               2、支持对聚合对象的多种遍历。 
     *               3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
     *               
     * 迭代模式缺点：1、通过增加具体的接口，有可能增加代码的阅读难度
     * 
     * 迭代模式适用场景：1、
     */

    ///<summary>
    /// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
    ///</summary>
publicabstractclass Aggregate
    {
        publicabstract Iterator CreateIterator();
    }
    ///<summary>
    /// 抽象迭代方法
    ///</summary>
publicabstractclass Iterator
    {
        publicabstractobject First();

        publicabstractobject Next();

        publicabstractbool IsDone();

        publicabstractobject CurrentItem();
    }

    ///<summary>
    /// 具体实现迭代类
    ///</summary>
publicclass ConcreteAggregate : Aggregate
    {
        private ArrayList _items=new ArrayList();


        publicint Count
        {
            get { returnthis._items.Count; }
        }
        publicobjectthis[int index]
        {
            get { returnthis._items[index]; }
            set { this._items[index] = value; }
        }

        ///<summary>
        /// 创建迭对象
        ///</summary>
        ///<returns></returns>
publicoverride Iterator CreateIterator()
        {
            returnnew ConcreteIterator(this);
        }
    }

    ///<summary>
    /// 具体迭代类
    ///</summary>
publicclass ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate;
        privateint _current =0;

        ///<summary>
        /// 将聚合类和具体迭代关联
        ///</summary>
        ///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
    
        //具体迭代方法
publicoverrideobject First()
        {
            return aggregate[0];   
        }

        publicoverrideobject Next()
        {
            object ret =null;
            if (_current<aggregate.Count-1)
            {
                ret = aggregate[_current++];
            }
            return ret;
        }

        publicoverridebool IsDone()
        {
            return _current >= aggregate.Count;
        }

        publicoverrideobject CurrentItem()
        {
            return aggregate[_current];
        }

    }

    publicclass AppCient
    {
        publicstaticvoid 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();
                
            }
        }
        
    }
}

using System;
using System.Text;
using System.Collections.Generic;
using System.Collections;
namespace 迭代模式
{

    /*
     * 迭代模式意图：提供一种方法顺序访问一个聚合对象中各个元素, 而又不需暴露该对象的内部表示。
     * 
     * 迭代模式实现要点：1、迭代抽象：访问一个聚合对象的内容而无需暴露它的内部表示。
     *                   2、迭代多态：为遍历不同的集合结构提供一个统一的接口，从而支持同样的算法在不同的集合结构上进行
     *                   3、迭代器的健壮性考虑：遍历的同时更改迭代器所在的集合结构，有可能导致问题。
     *                   
     * 迭代模式优点：1、访问一个聚合对象的内容而无需暴露它的内部表示。
     *               2、支持对聚合对象的多种遍历。 
     *               3、遍历不同的聚合结构提供一个统一的接口(即, 支持多态迭代)。
     *               
     * 迭代模式缺点：1、通过增加具体的接口，有可能增加代码的阅读难度
     * 
     * 迭代模式适用场景：1、
     */

    ///<summary>
    /// 聚集抽象类 并通过CreateIterator()方法创建一个迭代对象。
    ///</summary>
publicabstractclass Aggregate
    {
        publicabstract Iterator CreateIterator();
    }
    ///<summary>
    /// 抽象迭代方法
    ///</summary>
publicabstractclass Iterator
    {
        publicabstractobject First();

        publicabstractobject Next();

        publicabstractbool IsDone();

        publicabstractobject CurrentItem();
    }

    ///<summary>
    /// 具体实现迭代类
    ///</summary>
publicclass ConcreteAggregate : Aggregate
    {
        private ArrayList _items=new ArrayList();


        publicint Count
        {
            get { returnthis._items.Count; }
        }
        publicobjectthis[int index]
        {
            get { returnthis._items[index]; }
            set { this._items[index] = value; }
        }

        ///<summary>
        /// 创建迭对象
        ///</summary>
        ///<returns></returns>
publicoverride Iterator CreateIterator()
        {
            returnnew ConcreteIterator(this);
        }
    }

    ///<summary>
    /// 具体迭代类
    ///</summary>
publicclass ConcreteIterator : Iterator
    {
        private ConcreteAggregate aggregate;
        privateint _current =0;

        ///<summary>
        /// 将聚合类和具体迭代关联
        ///</summary>
        ///<param name="aggregate"></param>
public ConcreteIterator(ConcreteAggregate aggregate)
        {
            this.aggregate = aggregate;
        }
    
        //具体迭代方法
publicoverrideobject First()
        {
            return aggregate[0];   
        }

        publicoverrideobject Next()
        {
            object ret =null;
            if (_current<aggregate.Count-1)
            {
                ret = aggregate[_current++];
            }
            return ret;
        }

        publicoverridebool IsDone()
        {
            return _current >= aggregate.Count;
        }

        publicoverrideobject CurrentItem()
        {
            return aggregate[_current];
        }

    }

    publicclass AppCient
    {
        publicstaticvoid 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();
                
            }
        }
        
    }
}