c#你可能不知道的陷阱, ienumerable接口的示例代码详解：
ienumerable枚举器接口的重要性，说一万句话都不过分。几乎所有集合都实现了这个接口，linq的核心也依赖于这个万能的接口。c语言的for循环写得心烦，foreach就顺畅了很多。
我很喜欢这个接口，但在使用中也遇到不少的疑问，你是不是也有与我一样的困惑：
(1) ienumerable 与  ienumerator到底有什么区别
(2) 枚举能否越界访问，越界访问是什么后果？为什么在枚举中不能改变集合的值？
(3) linq的具体实现到底是怎样的，比如skip,它跳过了一些元素，那么这些元素被访问到了么？
(4) ienumerable 的本质是什么？
(5) ienumerable 枚举中是否会形成闭包？多个枚举过程会不会互相干扰？能否在枚举中动态改变枚举的元素？
….
如果感兴趣，我们接着下面的内容。
开始之前，我们的文章规定，枚举就是ienumerable，迭代就是ienumerator，已经被实例化（比如tolist()）就是集合。
1.  ienumerable 与  ienumeratorienumerable只有一个抽象方法：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的实现根本就是谎言，知道有这个东西就行了，不要太过依赖它。
2. foreach和movenext有区别吗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？这太复杂了。
枚举的特性在处理大数据的时候很有帮助，就是因为它的状态性，一个超大的文件，我只要每次读一部分，就可以顺次的读取下去，直到文件结束，由于不需要实例化集合，内存占用是很低的。对数据库也是如此，每次读取一部分，就能应对很多难以应付的情况。
3.在枚举中修改枚举器参数？在枚举过程中，集合是不能被修改的，比如在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阶段
}
如果你想知道，可以自己做个试验（在我附件里也有这个例子）。留给大家讨论。
4. 更多linq的讨论你可以在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性能呢？
5. 有关ienumerable枚举的更多问题(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接口的示例代码详解的详细内容。