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 语句来遍历自身元素。逻辑关系图：
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 = -;
private Person[] enumPersons;
public EnumeratorPeople(Person[] _persons){
enumPersons = new Person[_persons.Length];
for (int i = ; 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 = -;
}
} private Person[] persons;
public People(Person[] _persons){
persons = new Person[_persons.Length];
for (int i = ; 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();
}
逻辑关系图：
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 = ; 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 = -;
private Person[] persons;
public GenericEnumeratorPeople(Person[] _persons){
persons = new Person[_persons.Length];
for (int i = ; 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 = -; }
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>；
逻辑关系图：
· · 返回 IEnumerator 类型
返回此类型的迭代器通常为默认迭代器。
· People 类
public class People
{
private Person[] persons;
public People(Person[] _persons){
persons = new Person[_persons.Length];
for (int i = ; 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 = ; i < persons.Length; ++i)
yield return persons[i];
}
}
public IEnumerator IterMethod2() // [2].函数返回 IEnumerator (推荐)
{
for (int i = ; 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 = ; 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 = ; i < persons.Length; ++i)
yield return persons[i];
}
}
public IEnumerable IterMethod2() // [2].自定义迭代器 2 (推荐)
{
for (int i = ; 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>的迭代器，同理。
参考