一、引入问题
我们先看这段代码：这段代码的目的是要访问让foreach访问一个集合类，我们可以看到在集合类中，我建了一个索引。
问题是我在写foreach的时候，提示：
问题来了，foreach的原理是什么？？？？带着这个？我查了点资料，最终牵扯出千丝万缕！！
class Program
{
static void Main(string[] args)
{
ListClass list = new ListClass();
foreach(int i in list)
{
}
}
}
class ListClass
{
int[] intArray = new int[10] {1,2,3,4,5,6,7,8,9,10 };
public int this[int index]
{
get {return intArray[index]; }
}
}
先回答上面的问题：foreach调用集合类：
在 C# 中，集合类并非必须严格从 IEnumerable和 IEnumerator 继承才能与 foreach 兼容；只要类有所需的 GetEnumerator、MoveNext、Reset 和 Current 成员，便可以与 foreach 一起使用
也就是 foreach调用的集合类，必须能够返回一个迭代器
2.IEnumerable,IEnumerator接口介绍
IEnumerable 接口：公开枚举器，该枚举器支持在非泛型集合上进行简单迭代。
方法：GetEnumerator 返回一个循环访问集合的枚举数。
（http://msdn.microsoft.com/zh-cn/library/vstudio/system.collections.ienumerable(v=vs.100).aspx）
IEnumerator接口：支持对非泛型集合的简单迭代。
属性 ：current（集合中的当前元素）方法：movenext（）下个元素，reset()重置集合
（http://msdn.microsoft.com/zh-cn/library/vstudio/system.collections.ienumerator(v=vs.100).aspx）
两个接口的区别和联系：
1、一个Collection要支持foreach方式的遍历，必须实现IEnumerable接口（亦即，必须以某种方式返回IEnumerator object）。
2、IEnumerator object具体实现了iterator（通过MoveNext()，Reset()，Current）。
3、从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现枚举器（iterator）；IEnumerator是一个实现式的接口，IEnumerator object就是一个iterator。
4、IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，client可以通过IEnumerable的GetEnumerator()得到IEnumerator object，在这个意义上，将GetEnumerator()看作IEnumerator object的factory method也未尝不可。
IEnumerator 是所有枚举数的基接口。
枚举数只允许读取集合中的数据。枚举数无法用于修改基础集合。 这也是为什么说“不要在foreach循环中修改元素的原因 “.
最初，枚举数被定位于集合中第一个元素的前面。Reset 也将枚举数返回到此位置。在此位置，调用 Current 会引发异常。因此，在读取 Current 的值之前，必须调用 MoveNext 将枚举数提前到集合的第一个元素。 （开始currentPosition=-1,结束CurrentPosition=arraryList.length（也就是数组开始前的一个，和结束后的一个））
在调用 MoveNext 或 Reset 之前，Current 返回同一对象。MoveNext 将 Current 设置为下一个元素。
在传递到集合的末尾之后，枚举数放在集合中最后一个元素后面，且调用 MoveNext 会返回 false。如果最后一次调用 MoveNext 返回 false，则调用 Current 会引发异常。若要再次将 Current 设置为集合的第一个元素，可以调用 Reset，然后再调用 MoveNext。
只要集合保持不变，枚举数就将保持有效。如果对集合进行了更改（例如添加、修改或删除元素），则该枚举数将失效且不可恢复，并且下一次对 MoveNext 或 Reset 的调用将引发 InvalidOperationException。如果在 MoveNext 和 Current 之间修改集合，那么即使枚举数已经无效，Current 也将返回它所设置成的元素。
枚举数没有对集合的独占访问权；因此，枚举一个集合在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。
我们再看看在C#2.0和1.0是怎么实现迭代器的
在C#2.0中：我们通过调用的集合类实现IEnumberable接口实现迭代器
代码如下：
class Program
{
static void Main(string[] args)
{
listClass list = new listClass(); //声明一个类的对象
foreach (int item in list) //在foreach中in后面直接写集合类对象，由于foreach和实现了IEnumberable接口的集合类兼容，
执行foreach是会直接调用集合类中的GetEnumberator方法，通过该方法实现迭代访问集合类中的数据
{
Console.WriteLine(item.ToString());
}
Console.ReadKey();
}
}
class listClass : IEnumerable // 返回一个循环访问集合的枚举器。
{
public IEnumerator GetEnumerator() //返回一个循环访问集合的枚举数。
{
for (int i = 0; i < 10; i++)
{
yield return i; //yield是枚举器特有的，提示后面是迭代器
}
}
}
yield是在c#2.0中专门为IEnumberable设计的，正如上面所说：
IEnumberable是迭代的申明，通过GetEnumerator（）方法来获取一个枚举数，而IEnumberator才是迭代的执行.
而在这里面yield就相当于实现迭代器，并返回一个循环访问集合的枚举数。这就是C#2.0所做的工作
关于：yield
1、包含yield语句的方法或属性称为迭代块。迭代块必须声明为返回IEnumerator或IEnumerable接口。这个块可以包含多个yield return语句或yield break语句，但不能包含return语句。
yield return 语句返回集合的一个元素，并移动到下一个元素上。
yield break 语句：停止迭代
yield 语句只能出现在 iterator 块中，该块可用作方法、运算符或访问器的体。这类方法、运算符或访问器的体受以下约束的控制：
不允许不安全块。
方法、运算符或访问器的参数不能是 ref 或 out。
yield 语句不能出现在匿名方法中。有关更多信息，请参见匿名方法（C# 编程指南）。
当和 expression 一起使用时，yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。
有关更多信息，请参见http://msdn.microsoft.com/zh-cn/library/vstudio/9k7k7cf0.aspx
在C#1.0中：如何实现迭代器呢
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
namespace Interation1
{
class Program
{
//在C#1.0中使用迭代器
static void Main(string[] args)
{
EnumberabelTest interable=new EnumberabelTest ();
foreach (var i in interable)
{
Console.WriteLine(i);
}
Console.ReadKey();
}
}
//iterator的声明接口
public class EnumberabelTest : IEnumerable
{
int[] intArray = {1,2,3,4,5,6,7}; //创建需要实现迭代的数组（这个数组也可以在main中定义，然后再通过构造函数传进来）
public IEnumerator GetEnumerator()
{
return new EnmberatorTest(intArray); //通过IEnumerator获得迭代的数据
}
}
//这是创建Iterator（迭代器）具体实现接口 先执行MoveNext，再获取current
public class EnmberatorTest : IEnumerator
{
int Position = -1; //获取要迭代的数组，把其实位置设置为-1，
int end =0;
int[] intArray = null;
public EnmberatorTest(int[] intArray) //构造函数，迭代器初始化
{
this.intArray = intArray;
this.end = intArray.Length;
}
public object Current //返回当前位置的具体值
{
get
{
if (Position<-1 || Position>=end) //请求的值不再范围，抛出异常
{
throw new NotImplementedException();
}
return intArray[Position]; //返回数值
}
}
public bool MoveNext() //下移游标，
{
Position++;
return Position < intArray.Length; //返回false时自动结束一次迭代
}
public void Reset()
{
Position = -1;
}
}
}
显然要比2.0中要复杂的多。请注意，我们的数组是可以从mian方法直接传到EnuberabelTest,再传到Enumberator中去的！
我们再看看下面的实例，是从main方法传递一个数组，迭代开始的位置，并实现循环迭代。
class Program
{
static void Main(string[] args)
{
object[] values = new object[] {"a","b","c","d","e" };
InterationSample collection = new InterationSample(values, 2);
foreach( var i in collection )
{
Console.WriteLine(i.ToString());
}
Console.ReadKey();
}
}
class InterationSample:IEnumerable
{
public Object[] values;
public Int32 startPoint;
public InterationSample(Object[] values, Int32 startPoint)
{
this.values = values;
this.startPoint = startPoint;
}
public IEnumerator GetEnumerator()
{
return new IterationSampleEnumerator(this);
}
}
class IterationSampleEnumerator:IEnumerator
{
InterationSample parent; //迭代对象
Int32 position; //当前游标的位置
public IterationSampleEnumerator(InterationSample inter)
{
this.parent = inter;
this.position = -1;
}
public object Current
{
get {
if (position == -1 || position == parent.values.Length) //访问第一个元素和最后一个元素违法，
{
throw new NotImplementedException();
}
Int32 index = position + parent.startPoint; //根据positon实现一次循环
index = index % parent.values.Length;
return parent.values[index];
}
}
public bool MoveNext()
{
if (position != parent.values.Length)
{
position++;
}
return position < parent.values.Length;
}
public void Reset()
{
position = -1; //将游标重置为-1；
}
}
这个例子要复杂点：http://msdn.microsoft.com/zh-cn/library/system.collections.ienumerator(v=vs.80).aspx