C#你可能不知道的陷阱, IEnumerable介面的範例程式碼詳解：
IEnumerable枚舉器介面的重要性，說一萬句話都不過分。幾乎所有集合都實現了這個接口，Linq的核心也依賴這個萬能的接口。 C語言的for迴圈寫得心煩，foreach就順暢了很多。
我很喜歡這個接口，但在使用上也遇到不少的疑問，你是不是也有跟我一樣的困惑：
(1) IEnumerable 與 IEnumerator到底有什麼區別
(2) 列舉能否越界訪問，越界訪問是什麼後果？為什麼在枚舉中不能改變集合的值？
(3) Linq的具體實作到底是怎樣的，例如Skip,它跳過了一些元素，那麼這些元素被訪問到了麼？
(4) IEnumerable 的本質是什麼？
(5) IEnumerable 枚舉中是否會形成閉包？多個枚舉過程會不會互相干擾？能否在枚舉中動態改變枚舉的元素？
….
如果有興趣，我們接著下面的內容。
開始之前，我們的文章規定，枚舉就是IEnumerable，迭代就是IEnumerator，已經被實例化（例如ToList()）就是集合。
IEnumerable只有一個抽象方法：GetEnumerator()，而IEnumerator又是一個迭代器，真正實現了存取集合的功能。 IEnumerator只有一個Current屬性，MoveNext和Reset兩個方法。
有個小問題，只搞一個訪問器介面不就得了？為什麼要兩個看起來很容易混淆的介面呢？一個叫枚舉器，一個叫迭代器。因為
(1) 實作IEnumerator是個髒活累活，白白加了兩個方法一個屬性，而且這兩個方法其實並不好實現（後面會提到）。
(2) 它需要維護初始狀態，知道如何MoveNext ,如何結束，同時返回迭代的上一個狀態，這些並不容易。
(3)迭代顯然是非執行緒安全的，每次IEnumerable都會產生新的IEnumerator，從而形成多個互相不影響的迭代過程。在迭代過程中，不能修改迭代集合，否則不安全。
所以只要實作了IEnumerable，編譯器就會幫我們實作IEnumerator。何況絕大多數情況都是從現有集合繼承，一般不需要重寫MoveNext和Reset方法。 IEnumerable當然還有泛型實現，這個不影響問題的討論。
IEnumerable讓我們想起了單向鍊錶，C中需要一個指針域保存下一個節點的信息，那麼在IEnumerable中，誰幫忙保存了這個信息？這個過程佔用記憶體麼？ 是佔在程式區，還是堆區？
但是，IEnumerable也有它的缺點，它沒法後退，沒法跳躍（只能一個一個的跳過去），而且實現Reset並不容易,無法實現索引訪問。想想看， 如果是實例集合的枚舉過程，直接回到第0個元素就可以了，但是如果這個IEnumerable是漫長的訪問鏈條，想找到最初的根是很困難的！所 以CLR via C#的作者告訴你，其實很多Reset的實現根本就是謊言，知道有這個東西就行了，不要太過依賴它。
IEnumerable最大的特點是將存取的過程，交給了被訪客本身控制。在C語言中數組控制權是外在完全掌握的。這個介面卻在內部封裝存取了的過程，進一步提升了封裝性。例如下面：
public class People //定义一个简单的实体类
{
public string Name { get; set; }
public int Age { get; set; }
}
public class PersonList
{
private readonly List<People> peoples;
public PersonList() //为了方便，构造过程中插入元素
{
peoples = new List<People>();
for (int i = 0; i < 5; i++)
{
peoples.Add(new People {Name = "P" + i, Age = 30 + i});
}
}
public int OldAge = 31;
public IEnumerable<People> OlderPeoples
{
get
{
foreach (People people in _people)
{
if (people.Age > OldAge)
yield return people;
}
yield break;
}
}
}IEnumerable的本質是狀態機，它有點類似事件的概念，將實現丟到外面，實現程式碼間的穿越（想想星際效應），這是Linq的基礎。酷炫的迭代器，真的有我們想像的那麼簡單呢？
在C語言中，數組就是數組，實實在在的記憶體空間，那麼IEnumerable到底是什麼意思呢？如果它是由一個真正的集合（例如List）實現，那麼沒問題，也是實實在在的內存，可是如果是上述的例子呢？篩選返回的yield return 只返回了元素，但可能並不存在這個實際的集合，如果你將簡單的枚舉器的yield return 反編譯後看，會發現其實是一組switch-case, 編譯器在後台為我們做了大量的工作。
產生的新迭代器，如果不MoveNext，其實Current是空的，這是為什麼呢？為什麼一個迭代器不直接指向頭元素呢？
（感謝回答：就像C語言的單向鍊錶的頭指標一樣，這樣可以指定一個不包含任何元素的枚舉，程式設計起來更方便）
foreach每次往前移動一格，到頭了就停止。 等等，你確定它到頭了就會停止麼？我們來做個試驗：
public IEnumerable<People> Peoples1 //直接返回集合
{
get { return peoples; }
}public IEnumerable<People> Peoples2 //包含yield break;
{
get
{
foreach (var people in peoples)
{
yield return people;
}
yield break; //其实这个用不用都可以
}
}以上兩種，是我們常見的方式，注意第二種實現，ReSharper把yield break標成灰色（重複）。
我们再写下如下的测试代码，peopleList集合只有五个元素，但尝试去MoveNext 8次。可以把peopleList.Peoples1换成2,3，分别测试。
var peopleList = new PeopleList(); //内部构造函数插入了五个元素
IEnumerator<People> e1 = peopleList.Peoples1.GetEnumerator();
if (e1.Current == null)
{
Console.WriteLine("迭代器生成后Current为空");
}
int i = 0;
while (i<8) //总共只有五个元素，看看一直迭代会发生什么效果
{
e1.MoveNext();
if (e1.Current == null)
{
Console.WriteLine("迭代第{0}次后为空",i);
}
else
{
Console.WriteLine("迭代第{0}次后为{1}",i,e1.Current.Name);
}
i++;
}//PeopleEnumerable1 (直接返回集合) 迭代器生成后Current为空 迭代第0次后为P0 迭代第1次后为P1 迭代第2次后为P2 迭代第3次后为P3 迭代第4次后为P4 迭代第5次后为空 迭代第6次后为空 迭代第7次后为空 //PeopleEnumerable2 （不加yield break） 迭代器生成后Current为空 迭代第0次后为P0 迭代第1次后为P1 迭代第2次后为P2 迭代第3次后为P3 迭代第4次后为P4 迭代第5次后为P4 迭代第6次后为P4 迭代第7次后为P4 //PeopleEnumerable2 （加上yield break） 迭代器生成后Current为空 迭代第0次后为P0 迭代第1次后为P1 迭代第2次后为P2 迭代第3次后为P3 迭代第4次后为P4 迭代第5次后为P4 迭代第6次后为P4 迭代第7次后为P4 越界枚举测试结果
真让人吃惊，返回原始集合，越界之后就返回null了，但如果是MoveNext，不论有没有加yield break, 越界迭代后还是返回最后一个元素！ 也许就是我们在第1节里提到的，迭代器只返回上一次的状态，因为无法后移，所以就重复返回，那为什么List集合就不会这样呢？问题留给大家。
（感谢回答：越界枚举到底是null还是最后一个元素的问题，其实没有明确规定，具体看.NET的实现，在.NET Framework中，越界后依然是最后一个元素）。
不过各位看官尽管放心，在foreach的标准枚举过程下，枚举是肯定能枚举完的，这就说明了MoveNext和foreach两种在实现上的不同，显然foreach更安全。同时还注意，不能在yield过程中实现try-catch代码块，为什么呢？因为yield模式组合了来自不同位置的代码和逻辑，怎么可能靠编译给每个引用的代码块加上try-catch？这太复杂了。
枚举的特性在处理大数据的时候很有帮助，就是因为它的状态性，一个超大的文件，我只要每次读一部分，就可以顺次的读取下去，直到文件结束，由于不需要实例化集合，内存占用是很低的。对数据库也是如此，每次读取一部分，就能应对很多难以应付的情况。
在枚举过程中，集合是不能被修改的，比如在foreach循环中，如果插入或者删除一个元素，肯定会报运行时异常。有经验的程序员告诉 你，此时用for循环。for和foreach的本质区别是什么呢？
在MoveNext中，我突然改变了枚举的参数，使得它的数据量变多或者变少了，又会发生什么？
Console.WriteLine("不修改OldAge参数");
foreach (var olderPeople in peopleList.OlderPeoples)
{
Console.WriteLine(olderPeople);
}
Console.WriteLine("修改了OldAge参数");
i = 0;
foreach (var olderPeople in peopleList.OlderPeoples)
{
Console.WriteLine(olderPeople);
i++;
if (i ==1)
peopleList.OldAge = 33; //只枚举一次后，修改OldAge 的值
}测试结果是：
不修改OldAge参数 ID:2,NameP2,Age32 ID:3,NameP3,Age33 ID:4,NameP4,Age34 修改了OldAge参数 ID:2,NameP2,Age32 ID:4,NameP4,Age34
可以看到，在枚举过程中修改了控制枚举的值，能动态改变枚举的行为。上面是在一个yield结构中改变变量的情况，我们再试试在迭代器和Lambda表达式的情况（代码略）， 得到结果是：
在迭代中修改变量值 ID:2,NameP2,Age32 ID:4,NameP4,Age34 在Lambda表达式中修改变量值 ID:2,NameP2,Age32 ID:4,NameP4,Age34
可以看出，外部修改变量能够控制内部的迭代过程，动态改变了“集合的元素”。 这是一个好事，因为它的行为确实是对的；也是坏事：在迭代过程中，修改了变量的值，上下文语境变化，可是如果还按之前的语境进行处理，显然就会酿成大错。 这里和闭包没关系。
因此，如果一个枚举需要在上下文会发生变化的情况下保持原有的行为，就需要手动保存变量的副本。
如果你把两个集合A,B用Concat函数顺次拼接起来，也就是A-B, 而且不实例化，那么在枚举A的阶段中，修改集合B的元素，会报错么？ 为什么？
比如如下的测试代码：
List<People> peoples=new List<People>(){new People(){Name = "PA"}};
Console.WriteLine("将一个虚拟枚举A连接到集合B，并在枚举A阶段修改集合B的元素");
var e8 = peopleList.PeopleEnumerable1.Concat(peoples);
i = 0;
foreach (var people in e8)
{
Console.WriteLine(people);
i++;
if (i == 1)
peoples.Add(new People(){Name = "PB"}); //此时还在枚举PeopleEnumerable1阶段}
如果你想知道，可以自己做个试验（在我附件里也有这个例子）。留给大家讨论。
你可以在yield中插入任何代码，这就是延迟（Lazy）的表现，只是需要执行的时候才执行。 我们不难想象Linq很多函数的实现方式，比较有意思的包括Concat,它将两个集合连在了一起，就像下面这样：
public static IEnumerable<T> Concat<T>(this IEnumerable<T> source, IEnumerable<T> source2)
{
foreach (var r in source)
{
yield return r;
}
foreach (var r in source2)
{
yield return r;
}
}还有Select, Where都好实现，就不讨论了。
Skip怎么实现的呢？ 它跳过了集合中的一部分元素，我猜是这样的：
public static IEnumerable<T> Skip<T>(this IEnumerable<T> source, int count)
{
int t = 0;
foreach (var r in source)
{
t++;
if(t<=count)
continue;
yield return r;
}
}那么，被跳过的元素，到底被访问过没有？它的代码被执行了么？
Console.WriteLine("Skip的元素是否会被访问到？");
IEnumerable<People> e6 = peopleList.PeopleEnumerable1.Select(d =>
{
Console.WriteLine(d);
return d;
}).Skip(3);
Console.WriteLine("只枚举，什么都不做：");
foreach (var r in e6){}
Console.WriteLine("转换为实体集合，再次枚举");
IEnumerable<People> e7 = e6.ToList();
foreach (var r in e7){}测试结果如下：
只枚举，什么都不做： ID:0,NameP0,Age30 ID:1,NameP1,Age31 ID:2,NameP2,Age32 ID:3,NameP3,Age33 ID:4,NameP4,Age34 转换为实体集合，再次枚举 ID:0,NameP0,Age30 ID:1,NameP1,Age31 ID:2,NameP2,Age32 ID:3,NameP3,Age33 ID:4,NameP4,Age34
可以看出，Skip虽然是跳过，但还是会“访问”元素的，因此会执行额外的操作，比如lambda表达式，这不论是枚举器还是实体集合都是如此。这个角度说，要优化表达式，应当尽可能在linq中早的Skip和Take，以减少额外的副作用。
但对于Linq to SQL的实现中，显然Skip是做过额外优化的。我们是否也能优化Skip的实现，使得上层尽可能提升海量数据下的Skip性能呢？
(1) 枚举过程如何暂停？有暂停这一说么？ 如何取消？
(2) PLinq的实现原理是什么？它改变的到底是IEnumerable接口的哪种特性？是否产生了乱序枚举？这种乱序枚举到底是怎么实现？
(3) IEnumerable实现了链条结构，这是Linq的基础，但这个链条的本质是什么？
(4) 因為IEnumerable代表了狀態和延遲，因此不難理解許多非同步操作的本質就是IEnumerable。我有一次面試時候，問到了異步的實質，你說異步的實質是什麼？異步不是多線程！非同步的精彩，本質上是程式碼的重新組合，因為長時間的非同步操作就是狀態機。 。 。比如CCR庫。這裡不準備展開說，因為暫時超過了作者的知識儲備，下次再說。
(5) 如果用C語言來實現同樣的枚舉器，同樣酷炫的Linq,不靠編譯器能實現麼？先不提Lambda的梗，我們用函數指標。
(6) IEnumerable寫入MapReduce? Linq for MapReduce?
#(7) IEnumerable如何Sort? 實例化為一個集合再排序麼？如果是一個超大的虛擬集合,如何最佳化？
以上是C#你可能不知道的陷阱, IEnumerable介面的範例程式碼詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！
