C#中迭代器的概念和两种实现方式

1.首先我们看下IEnumerable接口定义：

  namespace System.Collections  
 {  
     // Summary:  
     //     Exposes the enumerator, which supports a simple iteration over a non-generic  
     //     collection.  
     [ComVisible(true)]  
     [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]  
     public interface IEnumerable  
     {  
         // Summary:  
         //     Returns an enumerator that iterates through a collection.  
         //  
         // Returns:  
         //     An System.Collections.IEnumerator object that can be used to iterate through  
         //     the collection.  
         [DispId(-4)]  
         IEnumerator GetEnumerator();  
     }  
 } 

 

这个接口是重中之重，迭代器就是实现这个接口才能使之迭代的。

2.C#的yield关键字您也必须知道
yield在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它有两种表现形式：
yield return <expression>;
yield break;

请注意：
expression 必须可以隐式转换为迭代器的 yield 类型
yield语句只能主线在迭代模块中，而不能出现在不安全模块，也不能出现在匿名方法中；当和 expression 一起使用时，yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。

3.介绍迭代器概念
其实所谓迭代就是指循环，迭代器是指实现该循环的一种方式。
迭代器是C#2.0增加的功能，它可以是方法、get访问器或运算符，最终它可以使您能够在类或结构中支持foreach迭代。在实现上您不必实现整个IEnumerable接口，您只需提供一个迭代器即可，当编译器监测到迭代器时间，她会自动生成IEnumerable 或 IEnumerable<T> 接口的 Current、MoveNext 和 Dispose 方法。
迭代器是可以返回相同类型的值的有序序列的一段代码，它使用yield return语句一次返回每个元素，使用yield break终止迭代，它的返回类型必须是IEnumerable、 IEnumerator、IEnumerable<T> 或 IEnumerator<T>。

3.创建迭代器最常用的方法是实现IEnumerable接口中的GetEnumerator方法，IEnumerable接口如下：

 using System;  
 using System.Collections;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
   
 namespace ctochina.net  
 {  
     class Program  
     {  
         static void Main(string[] args)  
         {  
             MyIterator myIterator = new MyIterator();  
   
             foreach (int i in myIterator)  
             {  
                 Console.WriteLine(i);  
             }  
         }  
     }  
   
     public class MyIterator  
     {  
         public IEnumerator GetEnumerator()  
         {   
             for(int i=1;i<8;i++)  
             {  
                 yield return i;  
             }  
         }  
     }  
   
 } 
 

输出：
1       2       3       4       5       6       7

注意System.Collections;命名空间的引用，因为IEnumerator在其中
由于是实现IEnumerable接口中的GetEnumerator方法，所以一个类中只能有一个GetEnumerator迭代。

4.另一种实现迭代的方法，代码接着上例如：

 using System;  
 using System.Collections;  
 using System.Collections.Generic;  
 using System.Linq;  
 using System.Text;  
   
 namespace ctochina.net  
 {  
     class Program  
     {  
         static void Main(string[] args)  
         {  
             MyIterator myIterator = new MyIterator();  
               
             //迭代一  
             foreach (int i in myIterator)  
             {  
                 Console.Write(i+"\t");  
             }  
   
             Console.WriteLine();  
   
             //迭代二  
             foreach (int i in myIterator.MyEnumerator_instance(2,8))  
             {  
                 Console.Write(i + "\t");  
             }  
   
             Console.WriteLine();  
   
             //迭代三  
             foreach (int i in MyIterator.MyEnumerator_static(2,8))  
             {  
                 Console.Write(i + "\t");  
             }  
   
         }  
     }  
   
     public class MyIterator  
     {  
         //实现 IEnumerable 接口的 GetEnumerator 方法来实现迭代  
         public IEnumerator GetEnumerator()  
         {   
             for(int i=1;i<8;i++)  
             {  
                 yield return i;  
             }  
         }  
   
         //IEnumerable 的实例实现迭代  
         public IEnumerable MyEnumerator_instance(int iLoop, int jLoop)  
         {   
             for(;iLoop<=jLoop;iLoop++)  
             {  
                 yield return iLoop;  
             }  
         }  
   
         //IEnumerable 的静态实现迭代  
         public static IEnumerable MyEnumerator_static(int iLoop,int jLoop)  
         {  
             for (; iLoop <= jLoop; iLoop++)  
             {  
                 yield return iLoop;  
             }  
         }  
     }  
   
 } 
 

输出：
1       2       3       4       5       6       7
2       3       4       5       6       7       8
2       3       4       5       6       7       8
可见这种方式灵活，一个类中可以有多个迭代的实现