Iterator迭代器_C#

先上代码

using UnityEngine;
using System.Collections;



namespace IteratorExample1
{
    public class IteratorExample1 : MonoBehaviour
    {
        void Start()
        {
            //IEnumerable第一次初始化
            Collection collection = new Collection();
            collection[0] = new Item("Item 0");
            collection[1] = new Item("Item 1");
            collection[2] = new Item("Item 2");
            collection[3] = new Item("Item 3");
            collection[4] = new Item("Item 4");
            collection[5] = new Item("Item 5");
            collection[6] = new Item("Item 6");
            collection[7] = new Item("Item 7");
            collection[8] = new Item("Item 8");

            // 生成迭代器
            Iterator iterator = collection.CreateIterator();

            //迭代器步长
            iterator.Step = 2;

            Debug.Log("Iterating collection:");

            for (Item item = iterator.First();
                !iterator.IsDone; item = iterator.Next())
            {
                Debug.Log(item.Name);
            }
        }
    }

    /// <summary>
    /// 元素
    /// </summary>
    class Item
    {
        private string _name;

        // Constructor
        public Item(string name)
        {
            this._name = name;
        }

        // Gets name
        public string Name
        {
            get { return _name; }
        }
    }

    /// <summary>
    /// 相当于IEnumerator
    /// </summary>
    interface IAbstractCollection
    {
        Iterator CreateIterator();

    }

    /// <summary>
    /// IEnumerable负责数据和生成相应迭代器实例
    /// </summary>
    class Collection : IAbstractCollection
    {
        private ArrayList _items = new ArrayList();

        public Iterator CreateIterator()
        {
            return new Iterator(this);//创建当前IEnumerable的迭代器
        }

        // 序列长度
        public int Count
        {
            get { return _items.Count; }
        }

        // 索引
        public object this[int index]
        {
            get { return _items[index]; }
            set { _items.Add(value); }
        }
    }

    /// <summary>
    /// IEnumerator
    /// </summary>
    interface IAbstractIterator
    {
        Item First();
        Item Next();
        bool IsDone { get; }
        Item CurrentItem { get; }
    }

    /// <summary>
    ///IEnumerator负责操作
    /// </summary>
    class Iterator : IAbstractIterator
    {
        private Collection _collection;
        private int _current = 0;
        private int _step = 1;

        //构造
        public Iterator(Collection collection)
        {
            this._collection = collection;
        }

        // Gets first item
        public Item First()
        {
            _current = 0;
            return _collection[_current] as Item;
        }

        // Gets next item
        public Item Next()
        {
            _current += _step;
            if (!IsDone)
                return _collection[_current] as Item;
            else
                return null;
        }

        // Gets or sets stepsize
        public int Step
        {
            get { return _step; }
            set { _step = value; }
        }

        // Gets current iterator item
        public Item CurrentItem
        {
            get { return _collection[_current] as Item; }
        }

        // Gets whether iteration is complete
        public bool IsDone
        {
            get { return _current >= _collection.Count; }
        }
    }
}

这里就要好好讲讲了，迭代器的定义

Provide a way to access the elements of an aggregate object sequentially without exposing its underlying representation. 
提供一种方法访问一个容器对象中各个元素，而又不需暴露该对象的内部细节。

foreach就是一种我们经常用的迭代器,官网的解释是

foreach 语句为类型实例中实现 System.Collections.IEnumerable 或 System.Collections.Generic.IEnumerable<T> 接口的每个元素执行语句或语句块。 foreach 语句不局限于这些类型，它可应用于满足以下条件的任何类型的实例：

• 具有公共无参数 GetEnumerator 方法，其返回类型为类、结构或接口类型。
• GetEnumerator 方法的返回类型具有公共 Current 属性和公共无参数 MoveNext 方法（其返回类型为 Boolean）。

那么实现一个迭代器模式，其实就是 实现IEnumerable和IEnumerator这两个接口，先看这两个接口的代码就很容易理解上面的代码了

using System.Runtime.InteropServices;

namespace System.Collections
{
    [ComVisible(true)]
    [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
    public interface IEnumerable
    {
        [DispId(-4)]
        IEnumerator GetEnumerator();
    }
}

using System.Runtime.InteropServices;

namespace System.Collections
{
    [ComVisible(true)]
    [Guid("496B0ABF-CDEE-11D3-88E8-00902754C43A")]
    public interface IEnumerator
    {
        object Current { get; }

        bool MoveNext();
        void Reset();
    }
}

是不是感觉很相似呢

先说IEnumerable接口，内部需要实现一个GetEnumerator方法，返回值是 IEnumerable 类型。在IEnumerator接口中，有一个属性，两个方法要实现，而且从名字上来看也能一目了然他们的作用。Current表示当前项的内容。接下来是MoveNext方法，他返回一个bool类型的值，判断迭代是否要往下执行。最后是Reset方法，一般是在这里重置下标，不过一般这个方法使用的比较少。

那么有人就问了，既然IEnumerable需要实现IEnumerator，为什么不直接写在一起呢，这样的好处是，可以对一个序列进行多次相互独立的迭代。