.NET类库中发现设计模式：迭代器模式

迭代模式：

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

 

.NET中应用：

 

 

   

   /// <summary>
    /// 抽象聚集
    /// </summary>
    public interface IList
    {
        IIterator GetIterator();
    }

    /// <summary>
    /// 抽象迭代器
    /// </summary>
    public interface IIterator
    {
        bool MoveNext();

        Object CurrentItem();

        void First();

        void Next();
    }

    /// <summary>
    /// 具体聚集
    /// </summary>
    public class ConcreteList : IList
    {
        int[] list;
        public ConcreteList()
        {
            list = new int[] { 1, 2, 3, 4, 5 };
        }

        public IIterator GetIterator()
        {
            return new ConcreteIterator(this);
        }

        public int Length
        {
            get { return list.Length; }
        }

        public int GetElement(int index)
        {
            return list[index];
        }
    }

    /// <summary>
    /// 具体迭代器
    /// </summary>
    public class ConcreteIterator : IIterator
    {
        private ConcreteList list;
        private int index;
        public ConcreteIterator(ConcreteList list)
        {
            this.list = list;
            index = 0;
        }

        public bool MoveNext()
        {
            if (index < list.Length)
                return true;
            else
                return false;
        }

        public Object CurrentItem()
        {
            return list.GetElement(index);
        }
        public void First()
        {
            index = 0;
        }
        public void Next()
        {
            if (index < list.Length)
            {
                index++;
            }
        }
    }

    /// <summary>
    /// 客户端程序
    /// </summary>
    public class Program
    {
        static void Main(string[] args)
        {
            IIterator iterator;

            IList list = new ConcreteList();

            iterator = list.GetIterator();

            while (iterator.MoveNext())
            {
                int i = (int)iterator.CurrentItem();
                Console.WriteLine(i.ToString());

                iterator.Next();
            }

            Console.Read();
        }
    }

 

        首先有一个抽象的聚集IList，所谓的聚集就是就是数据的集合，可以循环去访问它。它只有一个方法GetIterator()让子类去实现，用来获得一个迭代器对象。抽象的迭代器IIterator，它是用来访问聚集的类，封装了一些方法，用来把聚集中的数据按顺序读取出来。通常会有MoveNext()、CurrentItem()、Fisrt()、Next()等几个方法让子类去实现。具体的聚集ConcreteList ，它实现了抽象聚集中的唯一的方法，同时在里面保存了一组数据，这里我们加上Length属性和GetElement()方法是为了便于访问聚集中的数据。具体迭代器ConcreteIterator ，实现了抽象迭代器中的四个方法，在它的构造函数中需要接受一个具体聚集类型的参数，在这里面我们可以根据实际的情况去编写不同的迭代方式。

       IEnumerable和IEnumerator明显是在.NET Framework封装好的迭代器模式，实现了IEnumerator的迭代类从实现了IEnumerable的集合类中分离开来，这个类负责来处理枚举的状态（包括怎么表达当前数组中的元素和如何迭代集合中的元素），并把枚举的算法包含其中。这种方法能让你同时有几个用不同的方法枚举集合的迭代器，而不需要给集合添加任何的复杂性！

 public class Persons : IEnumerable
    {
        string[] m_Names;
        public Persons(params string[] Names)
        {
            m_Names = new string[Names.Length];

            Names.CopyTo(m_Names, 0);
        }
        public IEnumerator GetEnumerator()
        {
            foreach (string s in m_Names)
            {
                yield return s;
            }
        }
    }

    public class Program
    {
        static void Main(string[] args)
        {
            Persons arrPersons = new Persons("Michel", "Christine", "Mathieu", "Julien");
            foreach (string s in arrPersons)
            {
                Console.WriteLine(s);
            }
            Console.ReadLine();
        }
    }

 参考：http://www.cnblogs.com/Terrylee/archive/2006/09/16/Iterator_Pattern.html