迭代器
引言:
在C# 1.0中我们经常使用foreach来遍历一个集合中的元素,然而一个类型要能够使用foreach关键字来对其进行遍历必须实现IEnumerable或IEnumerable<T>接口,(之所以必须要实现IEnumerable这个接口,是因为foreach是迭代语句,要使用foreach必须要有一个迭代器才行的，然而IEnumerable接口中就有IEnumerator GetEnumerator()方法是返回迭代器的，所以实现了IEnumerable接口，就必须实现GetEnumerator()这个方法来返回迭代器，有了迭代器就自然就可以使用foreach语句了), 而在C# 1.0中要获得迭代器就必须实现IEnumerable接口中的GetEnumerator()方法，然而要实现一个迭代器就必须实现IEnumerator接口中的bool MoveNext()和void Reset()方法,以及Current属性,然而 C# 2.0中提供 yield关键字来简化迭代器的实现,这样在C# 2.0中如果我们要自定义一个迭代器就容易多了。下面就具体介绍了C# 2.0 中如何提供对迭代器的支持.
一、迭代器的介绍
迭代器大家可以想象成数据库的游标,即一个集合中的某个位置,C# 1.0中使用foreach语句实现了访问迭代器的内置支持，使用foreach使我们遍历集合更加容易（比使用for语句更加方便，并且也更加容易理解），foreach被编译后会调用GetEnumerator来返回一个迭代器，也就是一个集合中的初始位置（foreach其实也相当于是一个语法糖，把复杂的生成代码工作交给编译器去执行）。
二、C#1.0如何实现迭代器
在C# 1.0 中实现一个迭代器必须实现IEnumerator接口，下面代码演示了传统方式来实现一个自定义的迭代器：
class Program { static void Main(string[] args) { List<Person> personList = new List<Person> { new Person {Id = 1, Name = "wjire1"}, new Person {Id = 2, Name = "wjire2"}, new Person {Id = 3, Name = "wjire3"}, new Person {Id = 4, Name = "wjire4"}, new Person {Id = 5, Name = "wjire5"}, new Person {Id = 6, Name = "wjire6"}, }; Persons persons = new Persons(personList); foreach (var person in persons) { Console.WriteLine(person); } Console.ReadKey(); } } /// <summary> /// 人的集合 /// </summary> public class Persons : IEnumerable { private readonly List<Person> _persons; public Persons(List<Person> persons) { _persons = persons; } public IEnumerator GetEnumerator() { return new MyIterator(this); } public Person this[int index] => _persons[index]; public int Count => _persons.Count; } /// <summary> /// 要实现自己的迭代器, 必须实现 IEnumerator 接口,这样就必须实现 IEnumerator 接口中的MoveNext、Reset方法和Current属性 /// </summary> public class MyIterator : IEnumerator { private readonly Persons _persons; private int _index; private Person _current; public MyIterator(Persons persons) { _persons = persons; _index = 0; } public bool MoveNext() { if (_index + 1 <= _persons.Count) { this._current = _persons[_index]; _index++; return true; } return false; } public void Reset() { _index = 0; } public object Current => this._current; }
或者( 推荐 泛型接口 )
public class Person { public int Id { get; set; } public Person(int id) { this.Id = id; } public override string ToString() { return this.Id.ToString(); } } public class Persons : IEnumerable<Person> { public Person[] PersonArray { get; set; } public Person this[int index] => PersonArray[index]; public int Count => PersonArray.Length; public IEnumerator<Person> GetEnumerator() { return new PersonEnumerator(this); } IEnumerator IEnumerable.GetEnumerator() { return GetEnumerator(); } } public class PersonEnumerator : IEnumerator<Person> { private Persons persons { get; } private int index { get; set; } public PersonEnumerator(Persons ps) { this.persons = ps; this.index = 0; } public bool MoveNext() { if (index < persons.Count) { this.Current = persons[index]; index++; return true; } return false; } public void Reset() { index = 0; } public Person Current { get; set; } object IEnumerator.Current => this.Current; public void Dispose() { } }
static void Main(string[] args)
{
Person[] persons ={
new Person(1),
new Person(2),
new Person(3),
new Person(4),
new Person(5),
new Person(6),
};
Persons ps = new Persons { PersonArray = persons };
foreach (var person in ps)
{
Console.WriteLine(person);
}
Console.ReadKey();
}
三、使用C#2.0的新特性简化迭代器的实现
/// <summary> /// 人的集合 /// </summary> public class Persons : IEnumerable { private readonly List<Person> _persons; public Persons(List<Person> persons) { _persons = persons; } public IEnumerator GetEnumerator() { for (int i = 0; i < _persons.Count; i++) { //只需要这一句话就OK了 yield return _persons[i]; } } public Person this[int index] => _persons[index]; public int Count => _persons.Count; }
在上面代码中有一个yield return 语句，这个语句的作用就是告诉编译器GetEnumerator方法不是一个普通的方法，而是实现一个迭代器的方法，当编译器看到yield return语句时，编译器知道需要实现一个迭代器,所以编译器生成中间代码时为我们生成了一个IEnumerator接口的对象,大家可以通过Reflector工具进行查看,下面是通过Reflector工具得到一张截图:
从上面截图可以看出,yield return 语句其实是C#中提供的另一个语法糖，简化我们实现迭代器的源代码，把具体实现复杂迭代器的过程交给编译器帮我们去完成，看来C#编译器真是做得非常人性化，把复杂的工作留给自己做,让我们做一个简单的工作就好了。
迭代器工作流程
class Program { private static readonly string Padding = new string(' ', 30); static void Main(string[] args) { IEnumerable<int> iEnumerable = CreateIEnumerable();//在第一次 调用 iEnumerator.MoveNext() 方法前,CreateIEnumerable() 方法里面的代码不会被执行 IEnumerator<int> iEnumerator = iEnumerable.GetEnumerator(); Console.WriteLine("Starting to iterable"); while (true) { Console.WriteLine("Calling MoveNext()"); bool result = iEnumerator.MoveNext();//所有工作在 iEnumerator.MoveNext() 调用时就完成了,后面的 iEnumerator.Current 不会执行任何代码 Console.WriteLine(" Move result = {0}", result); if (!result) { break; } Console.WriteLine("Fetching Current"); Console.WriteLine($"Current result = {iEnumerator.Current}"); } Console.ReadKey(); } static IEnumerable<int> CreateIEnumerable() { Console.WriteLine($"{Padding} Start of CreateIEnumerable()"); for (int i = 0; i < 3; i++) { Console.WriteLine($"{Padding}About to yield {i}"); yield return i;//每次调用 iEnumerator.MoveNext() 方法时,代码执行到这里就停止,直到下一次调用 iEnumerator.MoveNext() 方法才会继续往下执行 Console.WriteLine($"{Padding}After yield"); } Console.WriteLine($"{Padding}Yielding final value"); yield return -1;//整个代码不会在这里结束,而是通过调用 iEnumerator.MoveNext() 方法返回 false 时才结束. Console.WriteLine($"{Padding}End of CreateIEnumerable"); } }
迭代器传参数
static void Test() { foreach (var i in CreateIEnumerable(DateTime.Now.AddSeconds(2))) { Console.WriteLine(i); if (i > 3) { Console.WriteLine("return"); return; } Thread.Sleep(300); } } static IEnumerable<int> CreateIEnumerable(DateTime stop) { try { for (int i = 0; i < 10000; i++) { if (DateTime.Now >= stop) { Console.WriteLine($"i = {i}"); yield break; } yield return i; } } finally { Console.WriteLine("yield end"); } }
