C#设计模式：迭代器模式（Iterator Pattern）

一，什么是迭代器模式（Iterator Pattern）

提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示

二，看下面例子：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _15.迭代器模式
{ //提供一种方法顺序访问一个容器对象中的各个元素，而又不需要暴露该对象的内部表示
    class Program
    {
        static void Main(string[] args)
        {
            Aggregate<object> a = new ConcreteAggregate<object>();
            a.add("中国人");
            a.add("美国人");
            a.add("日本人");
            Iterator<object> i = a.iterator();
            while (i.hasNext())
            {
                Console.WriteLine("获取当前：" + i.GetObj());
                Console.WriteLine("获取下一个：" + i.next());
                Console.WriteLine("是否是第一个：" + i.IsFirst());
                Console.WriteLine("是否是最后一个：" + i.IsLast());
            }
        }
    }
    /// <summary>
    /// 迭代器接口,迭代器接口负责定义,访问和遍历元素的接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface Iterator<T> where T : new()
    {
        /// <summary>
        ///是否还有下一个元素 true 表示有，false 表示没有 
        /// </summary>
        /// <returns></returns>
        bool hasNext();
        /// <summary>
        /// 返回当前位置的元素并将位置移至下一位 
        /// </summary>
        /// <returns></returns>
        T next();
        /// <summary>
        /// 判断是否是第一个
        /// </summary>
        /// <returns></returns>
        bool IsFirst();
        /// <summary>
        ///   判断游标是否是容器的最后一个
        /// </summary>
        /// <returns></returns>
        bool IsLast();
        /// <summary>
        /// 获取当前游标指向的元素
        /// </summary>
        /// <returns></returns>
        T GetObj();
    }
    /// <summary>
    /// 具体迭代器类,具体迭代器类的目的主要是实现迭代器接口，并记录遍历的当前位置。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConcreteIterator<T> : Iterator<T> where T : new()
    {
        private List<T> list = new List<T>();
        private int cursor = 0;

        public ConcreteIterator(List<T> list)
        {
            this.list = list;
        }
        /// <summary>
        ///是否还有下一个元素 true 表示有，false 表示没有 
        /// </summary>
        /// <returns></returns>
        public bool hasNext()
        {
            return cursor != list.Count();
        }
        /// <summary>
        /// 获取下一个
        /// </summary>
        /// <returns></returns>
        public T next()
        {
            T obj = new T();
            if (this.hasNext())
            {
                obj = this.list[cursor++];
            }
            return obj;
        }
        /// <summary>
        /// 判断是否是第一个
        /// </summary>
        /// <returns></returns>
        public bool IsFirst()
        {
            return cursor - 1 == 0 ? true : false;
        }
        /// <summary>
        ///   判断游标是否是容器的最后一个
        /// </summary>
        /// <returns></returns>
        public bool IsLast()
        {

            return cursor == (list.Count()) ? true : false;
        }
        /// <summary>
        /// 获取当前游标指向的元素
        /// </summary>
        /// <returns></returns>
        public T GetObj()
        {
            return list[cursor];
        }
    }
    /// <summary>
    /// 容器接口,容器接口负责提供创建具体迭代器角色的接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface Aggregate<T> where T : new()
    {
        /// <summary>
        ///  添加一个元素
        /// </summary>
        /// <param name="obj"></param>
        void add(T obj);
        /// <summary>
        /// 移除一个元素 
        /// </summary>
        /// <param name="obj"></param>
        void remove(T obj);
        /// <summary>
        /// 获取容器的迭代器 
        /// </summary>
        /// <returns></returns>
        Iterator<T> iterator();

    }
    /// <summary>
    /// 具体容器类。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class ConcreteAggregate<T> : Aggregate<T> where T : new()
    {
        private List<T> list = new List<T>();

        public void add(T obj)
        {
            list.Add(obj);
        }

        public void remove(T obj)
        {
            list.Remove(obj);
        }
        public Iterator<T> iterator()
        {
            return new ConcreteIterator<T>(list);
        }
    }
}