C#编程之IList、List、ArrayList、IList, ICollection、IEnumerable、IEnumerator、IQueryable 和 IEnumerable的

时间 2020-09-20

标签 c# 编程 ilist list arraylist icollection ienumerable ienumerator iqueryable 栏目 C# 繁體版

原文原文链接

额。。。今天看了半天Ilist<T>和List<T>的区别，而后惊奇的发现使用IList<T>仍是List<T>对个人项目来讲没有区别。。。

在C#中，数组、ArrayList都可以存储一组对象，那么三者到底有什么样的区别呢？

数组

数组在C#中最先出现的。在内存中是连续的，因此它的索引速度很是快，并且赋值与修改元素也很简单。

[csharp] view plain copy

print ?

string[] s=new string[2];
//赋值
s[0]="a";
s[1]="b";
//修改
s[1]="a1";

string[] s=new string[2];

//赋值
s[0]="a";
s[1]="b";
//修改
s[1]="a1";

可是数组存在一些不足的地方。在数组的两个数据间插入数据是很是麻烦的，并且在声明数组的时候必须指定数组的长度，数组的长度过长会形成内存浪费，太短会形成数据溢出。若是在声明数组时咱们不清楚数组的长度就会很麻烦。

ArrayList

针对数组的这些缺点，C#中最早提供了ArrayList对象来解决这些问题。

ArrayList是命名空间System.Collections下的一部分，在使用该类时必须进行引用，同时继承了IList接口，提供了数据存储和检索。ArrayList对象的大小是按照存储的数据来动态扩充与收缩的。因此在声明ArrayList对象时并不须要指定它的长度。

[csharp] view plain copy

print ?

ArrayList list1 = new ArrayList();
//新增数据
list1.Add("cde");
list1.Add(5678);
//修改数据
list[2] = 34;
//移除数据
list.RemoveAt(0);
//插入数据
list.Insert(0, "qwe");

ArrayList list1 = new ArrayList();

//新增数据
list1.Add("cde");
list1.Add(5678);

//修改数据
list[2] = 34;

//移除数据
list.RemoveAt(0);

//插入数据
list.Insert(0, "qwe");

从上面的例子看，ArrayList好像解决了数组中全部的缺点，为何又会有List?

咱们从上面的例子看，在List中，咱们不只插入了字符串cde，并且插入了数字5678。这样在ArrayList中插入不一样类型的数据是容许的。由于ArrayList会把插入其中的数据当object类型来处理，在咱们使用ArrayList处理数据时，极可能会报类型不匹配的错误，也就是ArrayList不是类型安全的。在存储或检索值类型时一般发生装箱和取消装箱的操做，带来很大的性能损耗。

装箱与拆箱的概念：

简单的说：

装箱：就是将值类型的数据打包到引用类型的实例中

好比将string类型的值赋值abc赋给object对象obj

[csharp] view plain copy

print ?

String i=”abc”;
object obj=(object)i;

String  i=”abc”;
object obj=(object)i;

拆箱：就是从引用数据中提取值类型

好比将object对象obj的值赋值给string类型的变量i

[csharp] view plain copy

print ?

object obj=”abc”;
string i=(string)obj;

object obj=”abc”;
string i=(string)obj;

装箱与拆箱的操做是很是耗性能的。

泛型List

由于ArrayList存在不安全类型与装箱拆箱的缺点，因此出现了泛型的概念。List类是ArrayList类的泛型等效类，它的大部分用法都与ArrayList类似，由于List类也继承了IList接口。最关键的区别在于，在声明List集合时，咱们同时须要为其声明List集合内的对象类型。

[csharp] view plain copy

print ?

List<string> list = new List<string>();
//新增数据
list.Add(“abc”);
//修改数据
list[0] = “def”;
//移除数据
list.RemoveAt(0);

List<string> list = new List<string>();

//新增数据
list.Add(“abc”);

//修改数据
list[0] = “def”;

//移除数据
list.RemoveAt(0);

上例中若是咱们往List集合中插入int数组123，IDE就会报错，且不能经过编译。这样就避免了前面讲的类型安全问题与装箱拆箱的性能问题了。

总结

数组的容量是固定的，只能一次获取或设置一个元素的值，而ArrayList或List<T>的容量可根据须要自动扩充、修改、删除、或插入数据。

数组能够具备多个维度，而ArrayhuoList<T>始终只有一个维度。可是，能够轻松的建立数组列表或列表的列表。特定类型（Object除外）的数组的性能优于ArrayList的性能。这事由于ArrayList的元素属于Object类型；因此在存储或检索值类型时一般发生装箱和拆箱的操做。不过，在不须要从新分配时（即最初容量十分接近列表的最大容量），List<T>的性能与同类型的数组十分相近。

在决定使用List<T>仍是使用ArrayList类（二者具备类似的功能）时，记住List<T>类在大多数状况下执行的更好而且是类型安全的。若是对List<T>类的类型T使用引用类型，则两个类的行为是彻底相同的。可是，若是对类型T使用值类型，则须要考虑实现和装箱的问题。

出处：https://blog.csdn.net/finish_dream/article/details/51627904html

==================================================node

IList, ICollection ,IEnumerable 很显然，这些都是集合接口的定义，先看看定义：sql

    // 摘要:
    //     表示可按照索引单独访问的对象的非泛型集合。
    [ComVisible(true)]
    public interface IList : ICollection, IEnumerable
    {
        // 摘要:
        //     获取一个值，该值指示 System.Collections.IList 是否具备固定大小。
        //
        // 返回结果:
        //     若是 System.Collections.IList 具备固定大小，则为 true；不然为 false。
        bool IsFixedSize { get; }
        //
        // 摘要:
        //     获取一个值，该值指示 System.Collections.IList 是否为只读。
        //
        // 返回结果:
        //     若是 System.Collections.IList 为只读，则为 true；不然为 false。
        bool IsReadOnly { get; }

        // 摘要:
        //     获取或设置指定索引处的元素。
        //
        // 参数:
        //   index:
        //     要得到或设置的元素从零开始的索引。
        //
        // 返回结果:
        //     指定索引处的元素。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     index 不是 System.Collections.IList 中的有效索引。
        //
        //   System.NotSupportedException:
        //     设置该属性，并且 System.Collections.IList 为只读。
        object this[int index] { get; set; }

        // 摘要:
        //     向 System.Collections.IList 中添加项。
        //
        // 参数:
        //   value:
        //     要添加到 System.Collections.IList 的对象。
        //
        // 返回结果:
        //     新元素所插入到的位置，或为 -1 以指示未将该项插入到集合中。
        //
        // 异常:
        //   System.NotSupportedException:
        //     System.Collections.IList 是只读的。- 或 -System.Collections.IList 具备固定大小。
        int Add(object value);
        //
        // 摘要:
        //     从 System.Collections.IList 中移除全部项。
        //
        // 异常:
        //   System.NotSupportedException:
        //     System.Collections.IList 是只读的。
        void Clear();
        //
        // 摘要:
        //     肯定 System.Collections.IList 是否包含特定值。
        //
        // 参数:
        //   value:
        //     要在 System.Collections.IList 中查找的对象。
        //
        // 返回结果:
        //     若是在 System.Collections.IList 中找到 System.Object，则为 true；不然为 false。
        bool Contains(object value);
        //
        // 摘要:
        //     肯定 System.Collections.IList 中特定项的索引。
        //
        // 参数:
        //   value:
        //     要在 System.Collections.IList 中查找的对象。
        //
        // 返回结果:
        //     若是在列表中找到 value，则为该项的索引；不然为 -1。
        int IndexOf(object value);
        //
        // 摘要:
        //     在 System.Collections.IList 中的指定索引处插入项。
        //
        // 参数:
        //   index:
        //     从零开始的索引，应在该位置插入 value。
        //
        //   value:
        //     要插入到 System.Collections.IList 中的对象。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     index 不是 System.Collections.IList 中的有效索引。
        //
        //   System.NotSupportedException:
        //     System.Collections.IList 是只读的。- 或 -System.Collections.IList 具备固定大小。
        //
        //   System.NullReferenceException:
        //     value 在 System.Collections.IList 中是 null 引用。
        void Insert(int index, object value);
        //
        // 摘要:
        //     从 System.Collections.IList 中移除特定对象的第一个匹配项。
        //
        // 参数:
        //   value:
        //     要从 System.Collections.IList 中移除的对象。
        //
        // 异常:
        //   System.NotSupportedException:
        //     System.Collections.IList 是只读的。- 或 -System.Collections.IList 具备固定大小。
        void Remove(object value);
        //
        // 摘要:
        //     移除指定索引处的 System.Collections.IList 项。
        //
        // 参数:
        //   index:
        //     从零开始的索引（属于要移除的项）。
        //
        // 异常:
        //   System.ArgumentOutOfRangeException:
        //     index 不是 System.Collections.IList 中的有效索引。
        //
        //   System.NotSupportedException:
        //     System.Collections.IList 是只读的。- 或 -System.Collections.IList 具备固定大小。
        void RemoveAt(int index);
    }

View Code

    // 摘要:
    //     定义全部非泛型集合的大小、枚举器和同步方法。
    [ComVisible(true)]
    public interface ICollection : IEnumerable
    {
        // 摘要:
        //     获取 System.Collections.ICollection 中包含的元素数。
        //
        // 返回结果:
        //     System.Collections.ICollection 中包含的元素数。
        int Count { get; }
        //
        // 摘要:
        //     获取一个值，该值指示是否同步对 System.Collections.ICollection 的访问（线程安全）。
        //
        // 返回结果:
        //     若是对 System.Collections.ICollection 的访问是同步的（线程安全），则为 true；不然为 false。
        bool IsSynchronized { get; }
        //
        // 摘要:
        //     获取一个可用于同步对 System.Collections.ICollection 的访问的对象。
        //
        // 返回结果:
        //     可用于同步对 System.Collections.ICollection 的访问的对象。
        object SyncRoot { get; }

        // 摘要:
        //     从特定的 System.Array 索引处开始，将 System.Collections.ICollection 的元素复制到一个 System.Array
        //     中。
        //
        // 参数:
        //   array:
        //     做为从 System.Collections.ICollection 复制的元素的目标位置的一维 System.Array。System.Array
        //     必须具备从零开始的索引。
        //
        //   index:
        //     array 中从零开始的索引，将在此处开始复制。
        //
        // 异常:
        //   System.ArgumentNullException:
        //     array 为 null。
        //
        //   System.ArgumentOutOfRangeException:
        //     index 小于零。
        //
        //   System.ArgumentException:
        //     array 是多维的。- 或 -源 System.Collections.ICollection 中的元素数目大于从 index 到目标 array
        //     末尾之间的可用空间。
        //
        //   System.ArgumentException:
        //     源 System.Collections.ICollection 的类型没法自动转换为目标 array 的类型。
        void CopyTo(Array array, int index);
    }

View Code

    // 摘要:
    //     公开枚举器，该枚举器支持在非泛型集合上进行简单迭代。
    [ComVisible(true)]
    [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
    public interface IEnumerable
    {
        // 摘要:
        //     返回一个循环访问集合的枚举器。
        //
        // 返回结果:
        //     可用于循环访问集合的 System.Collections.IEnumerator 对象。
        [DispId(-4)]
        IEnumerator GetEnumerator();
    }

View Code

能够看出，全部集合接口的祖宗是IEnumerable数据库

此接口只有一个方法 GetEnumerator()。是为了实现迭代器模式设计的接口。全部继承了IEnumerable的类，要使用foreach迭代器时，就须要使用该方法。所以也只有实现了该接口的类才可使用foreach。数组

ICollection继承自IEnumerable，IList继承自ICollection缓存

这两个接口都是为了给集合提供一些公用的方法。只是分了两个层次，IList比ICollection多几个方法，增长，移除成员。能够简单理解为：ICollection主要针对静态集合；IList主要针对动态集合。安全

IList 是 ICollection 接口的子代，而且是全部非泛型列表的基接口。IList 实现有三种类别：只读、固定大小和可变大小。没法修改只读 IList。固定大小的 IList 不容许添加或移除元素，但容许修改现有元素。可变大小的 IList 容许添加、移除和修改元素 (IList中的 IsFixedSize { get; } 和 bool IsReadOnly { get; })app

　　IList,ICollection,IEnumerable 在命名空间System.Collections中。

关于System.Collections空间

System.Collections命名空间包含可以使用的集合类和相关的接口，提供了集合的基本功能。 ide

该命名空间下的.NET非泛型集合类以下所示：oop

— System.Collections.ArrayList：数组集合类，使用大小可按动态增长的数组实现Ilist接口。

— System.Collections.BitArray：布尔集合类，管理位值的压缩数组，该值为布尔值。

— System.Collections.Queue：队列，表示对象的先进先出集合。

— System.Collections.Stack：堆栈，表示对象的简单的后进先出集合。

— System.Collections.Hashtable：哈希表，表示键/值对的集合，这些键/值对根据键的哈希代码进行组织

— System.Collections.SortedList：排序集合类，表示键/值对的集合，这些键和值按键排序并可按键和索引访问。

该命名空间下的.NET非泛型接口以下所示：

— System.Collections.ICollection：（继承于IEnumerable）定义全部集合的大小，枚举器和同步方法，能够获取集合中项的个数，并能把项复制到一个简单的数组类型中。

— System.Collections.IComparer：比较两个对象的方法

— System.Collections.IList：(继承于IEnumerable 和 ICollection)表示可按照索引单独访问一组对象,提供集合的项列表，并能够访问这些项。

— System.Collections.IDictionary：（继承于IEnumerable 和 ICollection）表示键/值对的集合

— System.Collections.IDictionaryEnumerator：枚举字典的元素

— System.Collections.IEnumerator：支持在集合上进行简单迭代，能够迭代集合中的项。支持在非泛型集合进行简单迭代。

　　IList<T>,ICollection<T>,IEnumerable<T> 在System.Collections.Generic 命名空间中。

System.Collections.Generic是.net中的泛型集合　

　 IList<T>,ICollection<T>,IEnumerable<T> 是2.0引入泛型之后新增的。主要是提升重用性与类型安全。
　　IEnumerable<T>继承自IEnumerable，ICollection<T>继承自IEnumerable<T>，List<T>继承自ICollection<T>
　　所以能够彻底使用泛型接口，而放弃使用ICollection和IList。泛型接口提供了更好的类型安全和编译时的检验。
补充：　　IEnumerable<T>和IEnumerable都只有一个方法。ICollection<T>和ICollection的结构是不同的。ICollection<T>比ICollection多几个方法。它包含了几个IList中的几个方法。也许是对之前的改进。

IEnumerable 和 IEnumerator

 
  IEnumerator

若是一个类实现了IEnumerator，也就是实现Current属性，MoveNext方法，Reset方法。只要实现这些方法，这个类就能够用foreach这种语法了。

IEnumerable接口主要实现了GetEnumerator方法，该方法返回一个IEnumerator。一个类实现IEnumerable接口后，调用foreach语法的时候，会自动的调用GetEnumerator方法，而后在这个IEnumerator中遍历。因此只要实现二者之中任意一个接口，就能够用foreach语法了。可是本质上都是对IEnumerator作foreach，只是一个是直接，一个是间接。

代码说明：

　　好比类Test，实现了IEnumerable，那么下面的代码

　　　　foreach (Test t in ts)

　　　　{ ... }

　　说明代码就功能上等同于下面的代码

　　　　IEnumerator td= ts.GetEnumerator();

　　　　while (td.MoveNext())

　　　　{

　　　　　　t = (Foo)td.Current()

　　　　　　...

　　　　}

　　若是一个类，同时实现了IEnumerator<T>,IEnumerable<T>，那么就是糟糕的设计由于用foreach语法的时候，会先调用IEnumerable的GetEnumerator方法。

　　IList<T> 和List<T>

　　首先IList 泛型接口是 ICollection 泛型接口的子代，而且是全部泛型列表的基接口。
　　它仅仅是全部泛型类型的接口，并无太多方法能够方便实用，若是仅仅是做为集合数据的承载体，确实，IList能够胜任。
　　不过，更多的时候，咱们要对集合数据进行处理，从中筛选数据或者排序。这个时候IList就心有余而力不足了。
　　一、当你只想使用接口的方法时,ILis<>这种方式比较好.他不获取实现这个接口的类的其余方法和字段，有效的节省空间．（既然子类是继承父类的子类又有本身的属性和方法，那么子类NEW出来后这些都应该有并且必须有的，不论放在父类的变量里面仍是自身类型的变量里面，否则的话向上转型后再向下转型数据就会丢失喽，太可怕了！）
　　二、IList <>是个接口,定义了一些操做方法这些方法要你本身去实现，List <>是泛型类,它已经实现了IList <>定义的那些方法
　　IList ilist=new List ();
　　List list=new List ();
　　这两行代码，从操做上来看，实际上都是建立了一个List对象的实例，也就是说，他们的操做没有区别。
　　只是用于保存这个操做的返回值变量类型不同而已。
　　那么，咱们能够这么理解，这两行代码的目的不同。
　　List List11 =new List ();
　　是想建立一个List，并且须要使用到List的功能，进行相关操做。
　　而IList IList11 =new List ();
　　只是想建立一个基于接口IList的对象的实例，只是这个接口是由List实现的。因此它只是但愿使用到IList接口规定的功能而已。

　　若是一个方法的返回值是IEnumerable<T> ,必须在方法后面使用.ToList（）方法才能获得一个集合数据

　　　List<XElement> grandchildElements = xlsElement.XPathSelectElements("//model").ToList();

　　使用.ToArray()方法，就会建立一个数组数据

　　　　XElement[] elements = xlsElement.Descendants(nodeName).ToArray();

　　集合数据要用foreach来遍历，而数组数据可使用下标操做。

出处：https://blog.csdn.net/superhoy/article/details/20908739

==========================================================================

楼主最近看了下

IQueryable 和 IEnumerable

的区别。

当真被忽悠的死去活来。。。

网上都说 IQueryable 和 IEnumerable区别很大，而后怎么着怎么着。。。

而后我就去测试了啊

先拿出个人数据库表结构。

这里是个人查询语句。比较简单

[csharp] view plain copy

print ?

TestDataEntities db = new TestDataEntities();
IQueryable<Orders> q = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);
IEnumerable<Orders> e = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);
Console.WriteLine("IQueryable : \r\n"+q.ToString());
Console.WriteLine("---------------------------------------------------------");
Console.WriteLine("IEnumerable : \r\n" + e.ToString());

TestDataEntities db = new TestDataEntities();
            IQueryable<Orders> q = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);
            IEnumerable<Orders> e = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);

            Console.WriteLine("IQueryable : \r\n"+q.ToString());
            Console.WriteLine("---------------------------------------------------------");
            Console.WriteLine("IEnumerable : \r\n" + e.ToString());

输出结果：

IQueryable :

[sql] view plain copy

print ?

SELECT TOP (2)
[Extent1].[id] AS [id],
[Extent1].[parentid] AS [parentid],
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
FROM [dbo].[Orders] AS [Extent1]
) AS [Extent1]
WHERE [Extent1].[row_number] > 1
ORDER BY [Extent1].[id] ASC

SELECT TOP (2) 
[Extent1].[id] AS [id], 
[Extent1].[parentid] AS [parentid], 
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
	FROM [dbo].[Orders] AS [Extent1]
)  AS [Extent1]
WHERE [Extent1].[row_number] > 1
ORDER BY [Extent1].[id] ASC

IEnumerable :

[sql] view plain copy

print ?

SELECT TOP (2)
[Extent1].[id] AS [id],
[Extent1].[parentid] AS [parentid],
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
FROM [dbo].[Orders] AS [Extent1]
) AS [Extent1]
WHERE [Extent1].[row_number] > 1
ORDER BY [Extent1].[id] ASC

SELECT TOP (2) 
[Extent1].[id] AS [id], 
[Extent1].[parentid] AS [parentid], 
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
	FROM [dbo].[Orders] AS [Extent1]
)  AS [Extent1]
WHERE [Extent1].[row_number] > 1
ORDER BY [Extent1].[id] ASC

有区别吗？没有哇！！！

后来楼主就较真了！！！！！！是的，较真了！！！为什么网上这么多人说有区别！

而后发现。。。。是这个缘由！~

看楼下代码

[csharp] view plain copy

print ?

TestDataEntities db = new TestDataEntities();
IQueryable<Orders> q = db.Orders.OrderBy(x => x.id).AsQueryable<Orders>().Skip(10).Take(2);
IEnumerable<Orders> e = db.Orders.OrderBy(x => x.id).AsEnumerable<Orders>().Skip(10).Take(2);
foreach (var item in q)
{
Console.WriteLine("123");
}
foreach (var item in e)
{
Console.WriteLine("234");
}

TestDataEntities db = new TestDataEntities();
            IQueryable<Orders> q = db.Orders.OrderBy(x => x.id).AsQueryable<Orders>().Skip(10).Take(2);
            IEnumerable<Orders> e = db.Orders.OrderBy(x => x.id).AsEnumerable<Orders>().Skip(10).Take(2);

            foreach (var item in q)
            {
                Console.WriteLine("123");
            }

            foreach (var item in e)
            {
                Console.WriteLine("234");
            }

缘由其实出在

AsQueryable 和 AsEnumerable

反正就是加载方式不一样

上面代码的sql语句是这样的！

IQueryable :

[sql] view plain copy

print ?

SELECT TOP (2)
[Extent1].[id] AS [id],
[Extent1].[parentid] AS [parentid],
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
FROM [dbo].[Orders] AS [Extent1]
) AS [Extent1]
WHERE [Extent1].[row_number] > 10
ORDER BY [Extent1].[id] ASC

SELECT TOP (2) 
[Extent1].[id] AS [id], 
[Extent1].[parentid] AS [parentid], 
[Extent1].[code] AS [code]
FROM ( SELECT [Extent1].[id] AS [id], [Extent1].[parentid] AS [parentid], [Extent1].[code] AS [code], row_number() OVER (ORDER BY [Extent1].[id] ASC) AS [row_number]
FROM [dbo].[Orders] AS [Extent1]
)  AS [Extent1]
WHERE [Extent1].[row_number] > 10
ORDER BY [Extent1].[id] ASC

IEnumerable :

[sql] view plain copy print ?

SELECT
[Extent1].[id] AS [id],
[Extent1].[parentid] AS [parentid],
[Extent1].[code] AS [code]
FROM [dbo].[Orders] AS [Extent1]
ORDER BY [Extent1].[id] ASC

SELECT 
[Extent1].[id] AS [id], 
[Extent1].[parentid] AS [parentid], 
[Extent1].[code] AS [code]
FROM [dbo].[Orders] AS [Extent1]
ORDER BY [Extent1].[id] ASC

是的，你没看错，奇怪在于IEnumerable生成的语句，是查询全表。

聪明的你确定会联想到。IEnumerable是经过缓存全表，而后才分页查找的！！！因此IEnumerable性能很差！

为何？？？？！！！！

由于：

IQueryable 是 linq to sql 这家伙操做数据库

IEnumerable 是 linq to object 这家伙操做内存

区别在这里！

固然网上还有说IQueryable 和 IEnumerable其余区别（这个楼主没有验证）

IEnumerable<T>查询必须在本地执行.而且执行查询前咱们必须把全部的数据加载到本地

总结一下：

IQueryable 是 linq to sql 这家伙操做数据库

IEnumerable 是 linq to object 这家伙操做内存

IEnumerable 会查询所有数据，而后在内存里进行分页或者筛选操做。

可是真正致使他们使用哪一种方式的，是AsQueryable() 和 AsEnumerable() ！！！！！

出处：https://blog.csdn.net/hanjun0612/article/details/50070081

===================================================================