C#編程之IList 、List 、ArrayList、IList, ICollection、IEnumerable、IEnumerator、IQueryable 和 IEnumerable的區別

本文轉載自查看原文 2018-06-16 00:06 2000 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/51627904

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

IList, ICollection ,IEnumerable 很顯然，這些都是集合接口的定義，先看看定義：

    // 摘要:
    //     表示可按照索引單獨訪問的對象的非泛型集合。
    [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; })

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

關於System.Collections空間

System.Collections命名空間包含可使用的集合類和相關的接口，提供了集合的基本功能。

該命名空間下的.NET非泛型集合類如下所示：

— 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就愛莫能助了。
　　1、當你只想使用接口的方法時,ILis<>這種方式比較好.他不獲取實現這個接口的類的其他方法和字段，有效的節省空間．（既然子類是繼承父類的子類又有自己的屬性和方法，那么子類NEW出來后這些都應該有而且必須有的，不論放在父類的變量里面還是自身類型的變量里面，不然的話向上轉型后再向下轉型數據就會丟失嘍，太可怕了！）
　　2、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

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

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 C#中IEnumerable、ICollection、IList、List之間的區別我也說 IEnumerable,ICollection,IList,List之間的區別 C# IQueryable和IEnumerable的區別 C#中IEnumerable和IEnumerator區別 Entity Framework中使用IEnumerable 、IQueryable 及IList 的區別 C#中IQueryable和IEnumerable的區別 c#中Array,ArrayList 與List 的區別、共性與轉換 IEnumerable 和IQueryable 區分 LINQ查詢中的IEnumerable 和IQueryable C# 基礎至集合-數組、List 、ArrayList、LinkedList、HashMap的一些區別