C#中foreach的实现原理

2017年04月01日 17:57:02 阅读数：3155更多

个人分类： C#

在探讨foreach如何内部如何实现这个问题之前，我们需要理解两个C#里边的接口，IEnumerable 与 IEnumerator. 在C#里边的遍历集合时用到的相关类中，IEnumerable是最基本的接口。这是一个可以进行泛型化的接口，比如说IEnumerable<User>.在微软的.NET推出了这两个接口后，才有了foreach的用法，可以说，foreach是建立在这两个接口的基础之上的,foreach的前提是其里边的容器要实现了IEnumerable接口。

IEnumerable 这个接口里边定义的内容非常简单，最重要的就是里边有一个抽象方法GetEnumerator. IEnumerable的意思是这个集合是可以遍历的，而这个GetEnumerator方法返回的IEnumerator的就是一个遍历器，用这个工具来遍历这个类。如果说IEnumerable 是一瓶香槟，那么IEnumerator就是一个开瓶器。在实现这个IEnumerable接口的时候，必须要实现这个GetEnumerator方法，要返回一个实例化的IEnumorator. 

下面来介绍一下这个IEnumorator接口。这个接口中定义的内容也很简单，包括Current，就是返回这个遍历工具所指向的那个容器的当前的元素，MoveNext 方法就是指向下一个元素，当遍历到最后没有元素时，返回一个false.当我们实现一个IEnumerable类的时候，我们的目的就应该是遍历这个集合，所以同时我们要实现IEnumerator这个工具类，定义我们自己的逻辑来告诉CLR我们怎么去遍历这个集合。 

下面是一个简单的例子，来说明一下这两个接口的用法。

[csharp] view plain copy

1. // Person类包括两个属性。  
2. public class Person  
3. {  
4.     public Person(string fName, string lName)  
5.     {  
6.         this.firstName = fName;  
7.         this.lastName = lName;  
8.     }  
9.     public string firstName;  
10.     public string lastName;  
11. }  
12. //People类就是Person的集合，里边使用了一个数组把单个的对象存在这个数组当中。而且因为实现了  
13. //IEnumerable接口，所以要实现GetEnumerator方法，返回一个实现了IEnumerator的类。  
14. public class People : IEnumerable  
15. {  
16.     private Person[] _people;  
17.     public People(Person[] pArray)  
18.     {  
19.         _people = new Person[pArray.Length];  
20.         for (int i = 0; i < pArray.Length; i++)  
21.         {  
22.             _people[i] = pArray[i];  
23.         }  
24.     }  
25.     public PeopleEnum GetEnumerator()  
26.     {  
27.         return new PeopleEnum(_people);  
28.     }  
29. }  
30. // 这里我们需要定义一套逻辑去遍历上边的集合。  
31. public class PeopleEnum : IEnumerator  
32. {  
33.     public Person[] _people;  
34.   
35.     int position = -1;  
36.     public PeopleEnum(Person[] list)  
37.     {  
38.         _people = list;  
39.     }  
40.     public bool MoveNext()  
41.     {  
42.         position++;  
43.         return (position < _people.Length);  
44.     }  
45.     public void Reset()  
46.     {  
47.         position = -1;  
48.     }  
49.     object IEnumerator.Current  
50.     {  
51.         get  
52.         {  
53.             return Current;  
54.         }  
55.     }  
56.     public Person Current  
57.     {  
58.         get  
59.         {  
60.             try  
61.             {  
62.                 return _people[position];  
63.             }  
64.             catch (IndexOutOfRangeException)  
65.             {  
66.                 throw new InvalidOperationException();  
67.             }  
68.         }  
69.     }  
70. }  
71. class App  
72. {  
73.     static void Main()  
74.     {  
75.         Person[] peopleArray = new Person[3]  
76.         {  
77.             new Person("John", "Smith"),  
78.             new Person("Jim", "Johnson"),  
79.             new Person("Sue", "Rabon"),  
80.         };  
81.         People peopleList = new People(peopleArray);  
82.   
83.         //在这里使用foreach就可以遍历这个集合了，因为它实现了IEnumerable接口。  
84.         foreach (Person p in peopleList)  
85.             Console.WriteLine(p.firstName + " " + p.lastName);  
86.      }  
87. }  
88. /* This code produces output similar to the following: 
89.  * 
90.  * John Smith 
91.  * Jim Johnson 
92.  * Sue Rabon 
93.  * 
94.  */  

如果说，foreach后台的逻辑是这么实现的？大概是这个样子的。上边的代码会被CLR翻译成这样。

[csharp] view plain copy

1. foreach (Person p in peopleList)  
2.             Console.WriteLine(p.firstName + " " + p.lastName);  
3. //翻译成  
4.   
5. IEnumerator enumerator = (peopleList).GetEnumerator();  
6. try {  
7.       while (enumerator.MoveNext()) {  
8.       Person element; //post C# 5  
9.       element = (Person )enumerator.Current;  
10.     //下边这句就是原来foreach方法体中的逻辑  
11.       Console.WriteLine(p.firstName + " " + p.lastName);  
12.    }  
13. }  
14. finally {  
15.    IDisposable disposable = enumerator as System.IDisposable;  
16.    if (disposable != null) disposable.Dispose();  
17. }  

附加：关于IEnumerable与ORM框架联合使用时候的延迟加载问题，以及Resharper对于此接口mutiple enumeration警告问题

使用IEnumerable的时候，Resharper经常会提示这个问题？这个问题意思是，这个集合对象可能会返回不同的遍历结果。

因为IEnumerable另外一个功能就是存放SQL一类的查询逻辑，注意，这里指的是查询逻辑，而不是真正的查询结果，也就是延迟加载。以下边的例子为例，可能objects中存放的是SQL查询逻辑。当第一次调用Any()方法的时候，会调用SQL语句查询到数据库中的结果，这时候是有一条数据的。但是objects调用First()方法来获取这个记录的时候，可能这时候的数据库已经被其他的程序改了，没有数据了，这时候就出现了dirty data的问题。所以，为了数据的一致性，需要在使用IEnumeralbe的时候，调用.ToList()方法把这些内容存放在一个个实实在在的容器中，这样就前后一致了。 

还有就是从代码性能角度考虑，每次都调用一下数据库会很慢，所以干脆一下全部把数据库中符合条件的结果放到内存List中，用的时候直接从内存中拿就快多了。

[csharp] view plain copy

1. public List<object> Foo(IEnumerable<object> objects)  
2. {  
3.     if(objects == null || !objects.Any())  
4.         throw new ArgumentException();  
5. var firstObject = objects.First();  
6.     var list= DoSomeThing(firstObject);          
7.     var secondList = DoSomeThingElse(objects);  
8.     list.AddRange(secondList);  
9. return list;  
10. }  
11.    

 IEnumerable在一些ORM框架中实现了延迟加载的功能。比如说，在框架自己定义的容器对象中，实现了特定的IEnumerator接口，在MoveNext中指定逻辑，连接数据库，获取对象等。

注：C#中Dictionary字典类介绍：http://www.cnblogs.com/txw1958/archive/2012/11/07/csharp-dictionary.html