C# ~ 从 IEnumerable / IEnumerator 到 IEnumerable / IEnumerator 到 yield

原創 万箭穿心殇 2020-06-03 04:54

IEnumerable / IEnumerator

首先，IEnumerable / IEnumerator 接口定义如下：

public interface IEnumerable  /// 可枚举接口
{
    IEnumerator GetEnumerator();
} 
public interface IEnumerator  /// 枚举器接口
{
    object Current { get; }  
    bool MoveNext();
    void Reset();
}

注：Current 没有 set 方法，在 foreach 中不能修改元素 var item 的值。
 · IEnumerable：声明式的接口，声明实现了该接口的类是可枚举类型；
 · IEnumerator：实现式的接口，IEnumerator 对象说明如何实现一个枚举器；

通过继承 IEnumerable / IEnumerator 接口实现自定义类使用 foreach 语句来遍历自身元素。逻辑关系图：
　　　精减的团队模型 - R模型

   People <-> MyClass 实现 IEnumerable 接口的 GetEnumerator()方法
   EnumeratorPeople <-> MyEnumerator 实现 IEnumerator 接口

·  定义Person类

　public class Person
　{
　　　private string name;
　　　private int age;

　　　public Person(string _name, int _age){
　　　　　　this.name = _name, this.age = _age;
　　　}
　　　public override string ToString(){
　　　　　　return string.Format("Name：{0}，Age：{1}.", name, age);
　　　}
　}

　　数组定义见主函数，以下2种遍历数组的方法等同，因为所有数组的基类都是 System.Array ，System.Array 类实现了 IEnumerable 接口，可以直接通过 GetEnumerator() 方法返回枚举数对象，枚举数对象可以依次返回请求的数组的元素。 

   // 利用 foreach 遍历数组
   foreach (var person in persons)
        Console.WriteLine(person.ToString());
   // 利用 IEnumerable ~ IEnumerator 遍历数组    
   IEnumerator it = persons.GetEnumerator();
   while (it.MoveNext()){
        Person obj = (Person)(it.Current);  // 需强制类型转换
        Console.WriteLine(obj.ToString());
   }

·  定义People类 (MyClass)

　　public class People 
　　{
        private Person[] persons;
        public People(Person[] _persons){ 
            persons = new Person[_persons.Length];
            for (int i = 0; i < _persons.Length; ++i){
                 persons[i] = _persons[i];    
            }
        }
　　}

　注意，People 类的 persons 数组是 private 变量，在主测函数中是无法遍历访问的。
　方法 1：将 private 更改为 public：

    foreach (var person in people.persons)
        Console.WriteLine(person.ToString());

　方法 2：People 类继承 IEnumerable 接口并实现 GetEnumerator() 方法，有 2 种方法：
　　[-1-]. 利用数组默认实现了 IEnumerable 和 IEnumerator 接口的事实，重新定义 People 类：

　　public class People : IEnumerable
　　{
        ... ...
        public IEnumerator GetEnumerator(){
            return persons.GetEnumerator();  // 方法 1
        }
　　}

　　[-2-]. 自定义枚举数类 (EnumeratorPeople 类如下)，继承并实现 IEnumerator 接口，重新定义 People 类：

　　public class People : IEnumerable
　　{
        ... ...
        public IEnumerator GetEnumerator(){
            return new EnumeratorPeople(persons);  // 方法 2 
        }
　　}

　此时，在方法2中自定义类可以使用如下 foreach 语句来遍历自身元素：

    foreach (var person in people)
        Console.WriteLine(person.ToString());

·  定义EnumeratorPeople类 (MyEnumerator)

　　public class EnumeratorPeople : IEnumerator
　　{
        private int position = -1;
        private Person[] persons;
        public EnumeratorPeople(Person[] _persons){ 
            persons = new Person[_persons.Length];
            for (int i = 0; i < _persons.Length; ++i)
                persons[i] = _persons[i];
        }

        public object Current{
            get{ return persons[position]; }
        }
        public bool MoveNext(){
            ++position;
            return (position < persons.Length); 
        }
        public void Reset(){
            position = -1;
        }
　　}

·  主函数测试代码

    class Program{
        static void Main(string[] args){
            Person[] persons = { 
                new Person("abc",25),  new Person("xyz",22),
                new Person("qwer",12), new Person("pm",20)  };
            People people = new People(persons);
        }
    }
总结

　一个类型是否支持foreach遍历，本质上是实现 IEnumerator 接口，2 种方法：
（1）自定义类只要继承 IEnumerable 接口并实现无参 GetEnumerator() 方法即可，最简单；
（2）在（1）基础上，定义 MyEnumerator 类继承并实现 IEnumerator 接口；

扩展 ：

　foreach 语句隐式调用集合的无参 GetEnumerator() 方法。其实，不论集合是否有实现 IEnumerable 接口，只要必须提供无参 GetEnumerator() 方法并返回包含 Current 属性和 MoveNext() 方法的 IEnumerator 对象即可，然后编译器会自动去绑定，无需依赖 IEnumerable 和 IEnumerator 接口，从而实现 foreach 对自定义集合类的遍历。

　　public class People
　　{
　　　　public class EnumeratorPeople
　　　　{ 
            private int position = -1;
            private Person[] enumPersons; 
            public EnumeratorPeople(Person[] _persons){
                enumPersons = new Person[_persons.Length];
                for (int i = 0; i < _persons.Length; ++i){
                    enumPersons[i] = _persons[i];
                }
            }

            public object Current{
                get { return enumPersons[position]; }
            }
            public bool MoveNext(){
                ++position;
                return ( position < enumPersons.Length );
            }
            public void Reset(){
                position = -1;
            }
       }

        private Person[] persons;
        public People(Person[] _persons){
            persons = new Person[_persons.Length];
            for (int i = 0; i < _persons.Length; ++i){
                persons[i] = _persons[i];
            }
        }
        public EnumeratorPeople GetEnumerator(){
            return new EnumeratorPeople(persons);
        }
　　}

此处，枚举数类声明为嵌套类，或者集成为一个类，也可以分成单独的 2 个类均可。

延伸问题
·  for 与 foreach
　for 先取全部再遍历，foreach 边遍历边取值；
·  Linq to Object 中返回 IEnumerable 类型?
　IEnumerable 是延迟加载的。

参考

·  传统遍历与迭代器；
·  IEnumerable和IEnumerator 详解；
·  自定义类实现foreach；深入理解 foreach；

IEnumerable<T> / IEnumerator<T>

优缺点对比
 ·  非泛型：非类型安全，返回object类型的引用、需要再转化为实际类型 (值类型需要装箱和拆箱)；
 ·  泛型：类型安全，直接返回实际类型的引用；
首先，IEnumerable<T> / IEnumerator<T> 接口定义如下：

public interface IEnumerable<out T> : IEnumerable  
{
    IEnumerator<T> GetEnumerator();
} 
public interface IEnumerator<out T> : IEnumerator, IDisposable  
{
    T Current { get; }
}

其中，接口 IDisposable 定义为：

public interface IDisposable{
    void Dispose();
}

逻辑关系图：
　　　精减的团队模型 - R模型　

   People <-> MyClass 实现 IEnumerable<T> 接口的 泛型GetEnumerator()方法
   GenEnumPeople <-> MyGenEnumerator 实现 IEnumerator<T> 接口

注：显式实现非泛型版本，在类中实现泛型版本！如下，类 MyGenEnumerator 实现了 IEnumerator<T>，类MyClass 实现了 IEnumerable<T> 接口。

public class MyClass : IEnumerable<T>
{
    public IEnumerator<T> GetEnumerator() { }     // IEnumerable<T> 版本
    IEnumerator IEnumerable.GetEnumerator() { }   // IEnumerable 版本
}

public class MyGenEnumerator : IEnumerator<T>
{
    public T Current { get; }            // IEnumerator<T> 版本
    public bool MoveNext() { }
    public void Reset() { }
    object IEnumerator.Current { get; }  // IEnumerator 版本
    public void Dispose() { }
}

·  定义 People 类 (MyClass)　　

   public class People : IEnumerable<Person>
   {
        private Person[] persons;
        public People(Person[] _persons){
            persons = new Person[_persons.Length];
            for (int i = 0; i < _persons.Length; ++i)
                persons[i] = _persons[i];
        }

        public IEnumerator<Person> GetEnumerator(){
            return new GenericEnumeratorPeople(persons);
        }
        IEnumerator IEnumerable.GetEnumerator(){   // 显式实现
            return this.GetEnumerator();
        }
   }

·  定义 GenEnumPeople 类 (MyGenEnumerator)

   public class GenEnumPeople : IEnumerator<Person>
   {
        private int position = -1;
        private Person[] persons;
        public GenericEnumeratorPeople(Person[] _persons){ 
            persons = new Person[_persons.Length];
            for (int i = 0; i < _persons.Length; ++i)
                persons[i] = _persons[i];
        }

        public Person Current{
            get { return persons[position]; }
        }
        object IEnumerator.Current{    // 显式实现
            get { return this.Current; }
        }
        public bool MoveNext(){
            ++position;
            return (position < persons.Length);
        }
        public void Reset() { position = -1; }
        public void Dispose() { Console.WriteLine("void Dispose()"); }
   }

其中，IDisposable 接口的学习参见 由 IDisposable 到 GC；

扩展 ：泛型委托应用；

迭代器

　　C#2.0 利用迭代器可以简单实现 GetEnumerator() 函数。迭代器是用于返回相同类型的值的有序集合的一段代码。利用 yield 关键字，实现控制权的传递和循环变量的暂存，使类或结构支持 foreach 迭代，而不必显式实现 IEnumerable 或 IEnumerator 接口，由 JIT 编译器辅助编译成实现了 IEnumerable 或 IEnumerator 接口的对象。yield return 提供了迭代器一个重要功能，即取到一个数据后马上返回该数据，不需要全部数据加载完毕，有效提高遍历效率（延迟加载）。
　-　yield 关键字用于指定返回的值，yield return 语句依次返回每个元素，yield break 语句终止迭代；
　-　到达 yield return 语句时，保存当前位置，下次调用迭代器时直接从当前位置继续执行；
　-　迭代器可以用作方法、运算符或get访问器的主体实现，yield 语句不能出现在匿名方法中；
　-　迭代器返回类型必须为 IEnumerable、IEnumerator、IEnumerable<T> 或 IEnumerator<T>；
　
逻辑关系图：　
　　　精减的团队模型 - R模型　
　　　
·　· 返回 IEnumerator 类型
　返回此类型的迭代器通常为默认迭代器。
　·  People 类

 public class People
 {
　　　private Person[] persons;
　　　public People(Person[] _persons){
　　　　　　persons = new Person[_persons.Length];
　　　　　　for (int i = 0; i < _persons.Length; ++i)
　　　　　　　　　persons[i] = _persons[i];
　　　}

　　　public IEnumerator GetEnumerator(){
　　　　　　return IterMethod1;      // [1]
　　　　　　return IterMethod2();    // [2]
　　　}
　　　public IEnumerator IterMethod1     // [1].属性返回 IEnumerator
　　　{
　　　　　　get {
　　　　　　　　　for (int i = 0; i < persons.Length; ++i)
　　　　　　　　　　　　yield return persons[i];
　　　　　　}
　　　}
　　　public IEnumerator IterMethod2()   // [2].函数返回 IEnumerator (推荐)
　　　{
　　　　　　for (int i = 0; i < persons.Length; ++i)
　　　　　　　　　yield return persons[i];
　　　}
 }

·  主函数测试代码

 People people = new People(persons);
 foreach (var person in people)
 　　　Console.WriteLine(person.ToString());

·　· 返回 IEnumerable 类型
　返回此类型的迭代器通常用于实现自定义迭代器。
　·  People 类

 public class People
 {
 　　　private Person[] persons;
 　　　public People(Person[] _persons){
　　　　　　persons = new Person[_persons.Length];
　　　　　　for (int i = 0; i < _persons.Length; ++i)
　　　　　　　　　persons[i] = _persons[i];
 　　　}
　　　
 　　　public IEnumerator GetEnumerator(){
　　　　　　return IterMethod1.GetEnumerator();      // [1]
　　　　　　return IterMethod2().GetEnumerator();    // [2]
 　　　}
 　　　public IEnumerable IterMethod1    // [1].自定义迭代器 1
 　　　{
　　　　　　get{
　　　　　　　　　for (int i = 0; i < persons.Length; ++i)
　　　　　　　　　　　　yield return persons[i];
　　　　　　}
 　　　}
 　　　public IEnumerable IterMethod2()  // [2].自定义迭代器 2 (推荐)
 　　　{
　　　　　　for (int i = 0; i < persons.Length; ++i)
　　　　　　　　　yield return persons[i];
 　　　}
 }

·  主函数测试代码

 People people = new People(persons);
 foreach (var person in people)   // 默认
 　　　Console.WriteLine(person.ToString());
 foreach (var person in people.IterMethod1)    // [1]
 　　　Console.WriteLine(person.ToString());
 foreach (var person in people.IterMethod2())  // [2]
 　　　Console.WriteLine(person.ToString());

　对于返回泛型IEnumerator<T>、IEnumerable<T>的迭代器，同理。

参考

·  foreach 与 yield；

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

正则表达式

万箭穿心殇 2020-02-21 13:45:56

正则表达式

万箭穿心殇 2020-02-21 13:45:56