C#中IEnumerable、ICollection、IList、IQueryable 、IQueryable 、List之间的区别

经常会用到这些集合，但是没有实在性的理解他们之间的区别，之前只是根据vs编辑器来看报错信息来选择用哪个集合，查询了一些网上的资料，介绍的还是蛮详细的，写下来记录一下，大部分都是借鉴他人以助理解！！！

举个栗子：

1             int[] myArray = { 1, 32, 43, 343 };
2             IEnumerator myie = myArray.GetEnumerator();
3             myie.Reset();
4             while (myie.MoveNext())
5             {
6                 int i = (int)myie.Current;
7                 Console.WriteLine("Value: {0}", i);
8             }

 通常我们这样会这样做：

 1 foreach (int item in myArray) 2 Console.WriteLine(item.ToString()); 

 使用for和foreach来遍历数组，而对于上面的语法却用的很少，但是对foreach的具体来历还很模糊！

要实现foreach的必须要实现IEnumerable和IEnumerator的接口，只有实现了它们，才能实现遍历，所以要讲foreach的来历，必须要把那两个接口给搞清楚点！

如果对这两个接口有了一定的了解后，只要实现那个GetEnumerator方法即可，而不需要实现于IEnumerable接口

1.IEnumerable

 1 具体的作用：就是使实现这个接口的对象成为可枚举类型。
 2  
 3 IEnumerable接口包含一个GetEnumerator方法，返回值为IEnumerator的类型！代码如下：
 4  
 5     public class MyColors : IEnumerable
 6     {
 7         string[] colors = { "Red", "Yellow", "Biue" };
 8         public IEnumerator GetEnumerator()
 9         {
10             return colors.GetEnumerator();
11         }
12     }
13  
14 那么我们在客户端进行调用的时候就可以这样做了！
15  
16             MyColors colors = new MyColors();
17             foreach (string item in colors)
18                 Console.WriteLine(item);

数组本身就实现了IEnumerator接口，那么两个接口都实现了，不就好实现foreach遍历了，其实在实现遍历枚举数的时候编译器会自动去调用数组中实现枚举数的类中的方法。

2.IEnumerator

接口的作用：实现可枚举数，首先看一下接口的定义：

包含一个属性两个方法

MoveNext → 把当前的项移动到下一项(类似于索引值)，返回一个bool值，这个bool值用来检查当前项是否超出了枚举数的范围！

Current → 获取当前项的值，返回一个object的类型

Reset → 顾名思义也就是把一些值恢复为默认值，比如把当前项恢复到默认状态值！

 1     public class MyIEnumerator : IEnumerator
 2     {
 3         public MyIEnumerator(string[] colors)
 4         {
 5             this.colors = new string[colors.Length];
 6             for (int i = 0; i < this.colors.Length; i++)
 7                 this.colors[i] = colors[i];
 8         }
 9  
10         string[] colors;   　　   //定义一个数组，用来存储数据
11  
12         int position = -1;  　　  //定义当前项的默认值，也就是索引值，一开始认识数组的索引从“0”开始，
13        
14  
15         public object Current       //根据当前项获取相应的值
16         {
17             get
18             {
19                 return colors[position];　　        //返回当前项的值，但是会做一个装箱的操作！
20             }
21         }
22  
23         public bool MoveNext()  　　　　            //移动到下一项
24         {
25           if (position < colors.Length - 1) 　　  //这就是设置默认值为-1的根据
26           {
27                 position++;
28                 return true;
29           }
30           else
31           {
32                 return false;
33           }
34         }
35  
36         //重置当前项的值，恢复为默认值
37         public void Reset()
38         {
39             this.position = -1;
40         }
41     }
42  
43 上面讲到的IEnumerable接口中GetEnumerator方法是获取要遍历的枚举数，在我们没有创建自己的遍历枚举数的类时，我们使用的是Array的遍历枚举数的方法，
但这个有的时候不一定适合我们，我们需要为自己定制一个更合适的，所以我们要创建自己的枚举数类(也就是上面的代码)，把第三点和第四点的代码合并起来(改动一点代码)，如下：
44  
45         public class MyColors   //: IEnumerable
46         {
47             string[] colors = { "Red", "Yellow", "Biue" };
48  
49             public IEnumerator GetEnumerator()
50             {
51                 return new MyIEnumerator(colors);
52             }
53         }

3.关于可枚举和枚举数

①可枚举类型 → 实现IEnumerable接口，可以不需要直接实现这个接口，但必须有个GetEnumerator方法，返回值类型必须为IEnumerator类型，也就是第四点最后一段代码中接口注释的那种写法！

②枚举数 → 实现IEnumerator接口，实现全部方法，首先是调用GetEnumerator返回一个类型为IEnumerator的枚举数，然后编译器会隐式的调用实现IEnumerator类中的方法和属性！

总结：所以实现foreach遍历，必须达到上面的两种条件才能进行遍历对象，他们可以写在一起也可以分开，最好是分开，进行职责分离，一个类干一件事总归是好事！也满足面向对象的单一指责设计原则。

下面的代码示例演示如何实现自定义集合的 IEnumerable 和 IEnumerator 接口

  1 using System;
  2 using System.Collections;
  3 using System.Collections.Generic;
  4 using System.Linq;
  5 using System.Text;
  6 using System.Threading.Tasks;
  7  
  8 namespace ConsoleApplication1
  9 {
 10     public class Person
 11     {
 12         public Person(string fName, string lName)
 13         {
 14             this.firstName = fName;
 15             this.lastName = lName;
 16         }
 17  
 18         public string firstName;
 19         public string lastName;
 20     }
 21  
 22     public class People : IEnumerable
 23     {
 24         private Person[] _people;
 25         public People(Person[] pArray)
 26         {
 27             _people = new Person[pArray.Length];
 28  
 29             for (int i = 0; i < pArray.Length; i++)
 30             {
 31                 _people[i] = pArray[i];
 32             }
 33         }
 34  
 35         IEnumerator IEnumerable.GetEnumerator()
 36         {
 37             return (IEnumerator)GetEnumerator();
 38         }
 39  
 40         public PeopleEnum GetEnumerator()
 41         {
 42             return new PeopleEnum(_people);
 43         }
 44     }
 45  
 46     public class PeopleEnum : IEnumerator
 47     {
 48         public Person[] _people;
 49  
 50         // Enumerators are positioned before the first element
 51         // until the first MoveNext() call.
 52         int position = -1;
 53  
 54         public PeopleEnum(Person[] list)
 55         {
 56             _people = list;
 57         }
 58  
 59         public bool MoveNext()
 60         {
 61             position++;
 62             return (position < _people.Length);
 63         }
 64  
 65         public void Reset()
 66         {
 67             position = -1;
 68         }
 69  
 70         object IEnumerator.Current
 71         {
 72             get
 73             {
 74                 return Current;
 75             }
 76         }
 77  
 78         public Person Current
 79         {
 80             get
 81             {
 82                 try
 83                 {
 84                     return _people[position];
 85                 }
 86                 catch (IndexOutOfRangeException)
 87                 {
 88                     throw new InvalidOperationException();
 89                 }
 90             }
 91         }
 92     }
 93  
 94  
 95     class Program
 96     {
 97         static void Main(string[] args)
 98         {
 99             Person[] peopleArray = new Person[3]
100             {
101                 new Person("John", "Smith"),
102                 new Person("Jim", "Johnson"),
103                 new Person("Sue", "Rabon"),
104             };
105  
106             People peopleList = new People(peopleArray);
107             foreach (Person p in peopleList)
108                 Console.WriteLine(p.firstName + " " + p.lastName);
109         }
110     }
111 }

1、IList 是 ICollection 接口的子代，并且是所有非泛型列表的基接口。IList 实现有三种类别：只读、固定大小和可变大小。无法修改只读 IList。固定大小的 IList 不允许添加或移除元素，但允许修改现有元素。可变大小的 IList 允许添加、移除和修改元素。

2、ICollection 接口是 System.Collections 命名空间中类的基接口。ICollection 接口扩展 IEnumerable；IDictionary 和 IList 则是扩展 ICollection 的更为专用的接口。 IDictionary 实现是键/值对的集合，如 Hashtable 类。 IList 实现是值的集合，其成员可通过索引访问，如 ArrayList 类。  某些集合（如 Queue 类和 Stack 类）限制对其元素的访问，它们直接实现 ICollection 接口。  如果 IDictionary 接口和 IList 接口都不能满足所需集合的要求，则从 ICollection 接口派生新集合类以提高灵活性。定义所有非泛型集合的大小、枚举器和同步方法。

3、IQueryable 提供对未指定数据 类型的特定数据源的查询进行计算的功能，IQueryable 接口由查询提供程序实现。 该接口只能由同时实现 IQueryable(Of T) 的提供程序实现。 如果该提供程序不实现 IQueryable(Of T)，则无法对提供程序数据源使用标准查询运算符。 IQueryable 接口继承 IEnumerable 接口，以便在前者表示一个查询时可以枚举该查询的结果。 枚举强制执行与 IQueryable 对象关联的表达式树。 “执行表达式树”的定义是查询提供程序所特有的。 例如，它可能涉及将表达式树转换为适用于基础数据源的查询语言。 在调用 Execute 方法时将执行不返回可枚举结果的查询。

IQueryable和IEnumberable and IList和List的区别

基本概念：

IEnumerable：使用的是LINQ to Object方式，它会将AsEnumerable()时对应的所有记录都先加载到内存，然后在此基础上再执行后来的Query

IQeurable（IQuerable）:不在内存加载持久数据,因为这家伙只是在组装SQL，(延迟执行) 到你要使用的时候，
例如 list.Tolist() or list.Count()的时候，数据才从数据库进行加载 (AsQueryable())。

IList（IList）：泛型接口是 ICollection 泛型接口的子代，作为所有泛型列表的基接口，
在用途方面如果作为数据集合的载体这是莫有问题的，只是如果需要对集合做各种的操作，例如 排序 编辑 统计等等，它不行。

List <> ：泛型类,它已经实现了IList <> 定义的那些方法,IList list=new List();
只是想创建一个基于接口IList的对象的实例，这个接口是由List实现的。只是希望使用到IList接口规定的功能而已　　

抽象场景：
其实在我们之前没有使用 ORM 的的很久很久以前，我们 在ADO.net 里面使用的 DataReader 和 DataAdapter or DataSet 和这几个货的基本原理都接近的，
就是读取数据的时候，一个必须独占着数据库的连接，而另一个就是先把数据库的的局加载到了自己本地，然后再进行操作。

使用场景模拟：

1 //IList
2 IList users = res.ToList(); //此时已把users加载到内存，而每个user的关联实体（UserInfos）未
3                                        //被加载，所以下一行代码无法顺利通过
4 var ss = users.Where(p => p.UserInfos.ID != 3); //此处报错，因为P的UserInfos实体无法被加载
5   
6 // IQuerable的
7 IQueryable users = res.AsQueryable(); //users未被立即加载，关联实体可通过“延迟加载”获
8                                    //得
9 var ss = users.Where(p => p.UserInfos.ID != 3);//此处顺利获得对应的ss

总结:

基于性能和数据一致性这两点，使用IQueryable时必须谨慎，而在大多数情况下我们应使用IList。

1.当你打算马上使用查询后的结果(比如循环作逻辑处理或者填充到一个table/grid中)，

并且你不介意该查询即时被执行后的结果可以供调用者(Consummer)作后续查询(比如这是一个"GetAll"的方法)，或者你希望该查执行，使用ToList()
2.当你希望查询后的结果可以供调用者(Consummer)作后续查询(比如这是一个"GetAll"的方法)，或者你希望该查询延时执行，使用AsQueryable()
3.按照功能由低到高：List IList IQueryable IEnumerable
4.按照性能由低到高：IEnumerable IQueryable IList List