C# foreach和迭代器

最新推荐文章于 2023-07-28 11:24:10 发布

莫之

最新推荐文章于 2023-07-28 11:24:10 发布

阅读量1k

点赞数 1

分类专栏： C#编程

本文链接：https://blog.csdn.net/qq_36383623/article/details/109390560

版权

C#编程专栏收录该内容

28 篇文章 1 订阅

订阅专栏

一、从foreach遍历数组开始

是什么让类成为集合，IEnumerable<T>

.NET中的几何本质上是一个类，它实现了IEnumerable<T>或非泛型类型IEnumerable；任何一个集合如果想支持对集合执行遍历操作，就必须要实现该接口；

cnblog：C#的枚举数(Enumerator)和可枚举类型(Enumerable)；

foreach遍历数组

“运行时”不是直接支持foreach语句来遍历数组，C#编译器会对代码进行必要的转换；

C#编译器会用CIL来创建一个等价的for循环，注意foreach要依赖于数组的Length属性和数组索引操作符的支持，知道Length属性的值后，C#编译器才可以用for语句遍历数组中的每一个元素；

foreach和IEnumerable<T>

不是所有类型的集合都包含已知数量的元素，很多集合类，包括Stack<T>、Queue<T>等都不支持按照索引获取元素，因此，需要一种更常规的方式遍历元素集合。迭代器模式提供了这种能力，只要能确定第一个元素、下一个元素和最后一个元素，就不需要知道元素综合；

System.Collections.Generic.IEnumerator<T>和System.Collections.IEnumerator接口的设计目标就是允许使用迭代器模式来遍历元素集合，而不是长度-索引模式；

IEnumerator<T>从IEnumerator派生，后者包含3个成员，第一个成员是bool MoveNext()，利用这个方法，可以从集合中的额一个元素移动到下一个元素，同时检测是否已枚举完集合中的每个元素；

第二个成员是只读属性current，用于返回当前元素，Current在IEnumerator<T>中进行了重载，提供了类型特有的实现；

状态共享

加入有两个循环交错遍历同一个集合，比如一个foreach嵌套了另一个foreach，那么集合必须维持当前元素的一个状态指示器，确保当调用MoveNext()时，能正确定位下一个元素，但是这种情况，交错的循环会相互干扰；

为了解决这个问题，集合类不直接支持IEnumerator<T>和IEnumerator接口，它需要实现另一个接口IEnumerable<T>，它唯一的方法就是GetEnumerator()，这个方法的作用是返回支持IEnumerator<T>的一个对象实例；这个对象实例相当于一个游标，用来维护循环遍历的状态；

可以理解IEnumerable是为了解决交错遍历问题而进行的一层抽象，是对IEnumerator进行的封装（计算机科学中的任何问题都可以通过添加一层抽象来解决）；

foreach内不要修改集合

在foreach循环执行期间，集合中的元素技术是不能变动的，集合项本身一般也不能修改；

二、迭代器

迭代器是实现类的方法的一种途径，C#编译器在遇到迭代器时，会把它的内容扩展成实现了枚举数模式的CIL代码；由于C#编译器在生成的CIL代码中仍然采用枚举数模式，所以在使用迭代器之后并不会带来真正的运行时性能优势，但是它可以提高程序员的编程效率；

迭代器语法

通过实现IEnumerable接口的GetEnumerator()方法，为泛型数据结构BinaryTree<T>声明了一个迭代器；

    public class BinaryTree<T> : IEnumerable<T> {
        public BinaryTree(T value) {
            Value = value;
        }

        #region IEnumerable<T>
        public IEnumerator<T> GetEnumerator() { 
        
        }
        #endregion IEnumerable<T>
        public T Value { get; }
        public Pair<BinaryTree<T>> SubItems { get; set; }
    }
    public struct Pair<T> {
        public Pair(T first, T second) : this() {
            First = first;
            Second = second;
        }
        public T First { get; }
        public T Second { get; }
    }

迭代器和状态

GetEnumerator()在foreach语句首次被调用时，会创建一个迭代器对象，其状态被初始化为特殊的起始状态，只要foreach语句继续，迭代器就会一直维持其状态；

将yield return语句放到循环中，我们不必要对每个yield return语句进行硬编码，可以使用yield return语句从循环结构中返回值；

使用yield break可以强制取消更多的迭代；

迭代器是如何工作的

C#编译器遇到foreach语句后，会根据枚举数模式将代码展开成恰当的CIL，在生成的代码中，C#编译器首先创建一个嵌套的私有类来实现IEnumerator<T>接口，以及它的Current属性和MoveNext()方法。Current属性返回和迭代器的返回类型对应的一个类型。

    public class Pair<T> : IEnumerable<T> {
        #region IEnumerable<T>
        public virtual IEnumerator<T> GetEnumerator() { 
        
        }
        #endregion IEnumerable<T>

        public virtual System.Collections.IEnumerator
            System.Collections.IEnumerable.GetEnumerator()
        {
            return new GetEnumerator();
        }

        private sealed class __ListEnumerator<T> : IEnumerator<T> {
            public __ListEnumerator(int itemCount){
                _ItemCount = itemCount;
            }
            public object Current {
                get {
                    return _Current;
                }
            }
            public bool MoveNext() {
                switch (_ItemCount) {
                    case 0:
                        _Current = _Pair.First;
                        _ItemCount++;
                        return true;
                    case 1:
                        _Current = _Pair.Second;
                        _ItemCount++;
                        return true;
                    default:
                        return false;
                }
            }
        }
    }

在上面的代码中，编译器拿掉了yield return语句，而且生成的类和手工编写的类基本一致，所以C#迭代器的性能特征和手工实现枚举数模式的性能特征是一致的，虽然性能没有提升，但是开发效率显著提高了；