.net基础---迭代器

迭代器

迭代器是一种快速访问集合元素的方法，它通过封装记录当前访问到的集合元素的下标值（position），访问当前元素直接获取其中的当前值即可（当前值通过下标获取）；访问下一元素时通过判断是否存在下一个元素，如果存在则通过moveNext方式，将当前访问的下标值往后移（+1）。

在.net中迭代器的实现主要就是foreach语法。能够使用foreach的语法的必须实现IEnumerable接口。IEnumerable定义GetEnumerator接口返回的IEnumerator，而IEmerator接口则是迭代的真正实现。

示例代码

    /// <summary>
    /// 可迭代类（集合，例如List）
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class CustomerEnumable<T> : IEnumerable<T>
    {

        private T[] _data;
        #region 集合本来的属性
        public int Count => _data.Length;
        /// <summary>
        /// 索引器
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get { return _data[index]; }
            set { _data[index] = value; }
        }
        //........
       
        public CustomerEnumable(T[] data)
        {
            this._data = data;
        }
        #endregion
        /// <summary>
        /// 获取非泛型迭代器
        /// </summary>
        /// <returns></returns>
        public IEnumerator GetEnumerator()
        {
            return new CustomerEnumerator<T>(_data);
        }
        /// <summary>
        /// 获取泛型迭代器
        /// </summary>
        /// <returns></returns>
        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return new CustomerEnumerator<T>(_data);
        }
    }
    /// <summary>
    /// CustomerEnumable的迭代器实现
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class CustomerEnumerator<T> : IEnumerator<T>
    {
        private int _position = -1;
        private T[] _data;
        /// <summary>
        /// 当前值
        /// </summary>
        public object Current => _data[_position];
        /// <summary>
        /// 当前值(泛型)
        /// </summary>
        T IEnumerator<T>.Current => _data[_position];

        public CustomerEnumerator(T[] data )
        {
            this._data = data;
        }
        public void Dispose()
        {
            this._data = null;
        }
        /// <summary>
        /// 判断下一个元素是否存在，存在则将position加1，并返回true,否则返回false表示无下一个元素
        /// </summary>
        /// <returns></returns>
        public bool MoveNext()
        {
            if (_position < _data.Length - 1)
            {
                _position++;
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// 重设
        /// </summary>
        public void Reset()
        {
            this._position = -1;
        }
    }

 

 

使用示例

            string[] brands = new string[] { "Red b", "Green g", "Yellow d", "Blue Z" };
            var brandList = new CustomerEnumable<string>(brands);

            
            //1、使用for遍历
            for (int i = 0; i < brandList.Count; i++)
            {
                Console.WriteLine(brandList[i]);   
            }
            //2、使用foreach语法
            foreach (var brandItem in brandList)
            {
                Console.WriteLine(brandItem);
            }
            //3、直接通过迭代器访问（其实就是foreach的实际实现） 
            var brandEnumerator = brandList.GetEnumerator();//因为GetEnumerator方法每次都是返回新的迭代实现，所以无需手工调用Reset
            while (brandEnumerator.MoveNext())
            {
                Console.WriteLine(brandEnumerator.Current);
            }

 

 

附：

1、foreach遍历集合比直接使用for要快？

这个是不一定的，因为通过了解迭代器的实现，我们可以知道它最终还是按照下标去顺序遍历的。而这些集合基本上都是内存连续的。当我们使用for也是按照下标顺序获取（不存在跳跃的情况下），其实性能是差不多的。

当然foreach语法比较简洁，不用我们去维护下标值，所以还是建议使用foreach的。

2、.net中yield关键字其实是一种语法糖，最终还是通过实现IEnumberable<T>、IEnumberable、IEnumberator<T>和IEnumberator接口实现的迭代功能（可以通过IL码查看其内部实现，此处略）。

简单示例

        public IEnumerable<string> GetSubjectEnumerable()
        {
            yield return "C#";
            yield return "Java";
            yield return "Python";
            yield return "Go";
        }

 

            foreach (var item in GetSubjectEnumerable())
            {
                Console.WriteLine(item);
            }

 

 

 

---------

以上就是对迭代器概念的回顾