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 ?
  1. string[] s=new string[2];  
  2.   
  3. //賦值  
  4. s[0]="a";  
  5. s[1]="b";  
  6. //修改  
  7. 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 ?
  1. ArrayList list1 = new ArrayList();  
  2.   
  3. //新增數據  
  4. list1.Add("cde");  
  5. list1.Add(5678);  
  6.   
  7. //修改數據  
  8. list[2] = 34;  
  9.   
  10. //移除數據  
  11. list.RemoveAt(0);  
  12.   
  13. //插入數據  
  14. 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 ?
  1. String  i=」abc」;  
  2. object obj=(object)i;  
String  i=」abc」;
object obj=(object)i;
       拆箱：就是從引用數據中提取值類型
       好比將object對象obj的值賦值給string類型的變量i
[csharp] view plain copy
print ?
  1. object obj=」abc」;  
  2. 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 ?
  1. List<string> list = new List<string>();  
  2.   
  3. //新增數據  
  4. list.Add(「abc」);  
  5.   
  6. //修改數據  
  7. list[0] = 「def」;  
  8.   
  9. //移除數據  
  10. 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 ?
  1. TestDataEntities db = new TestDataEntities();  
  2.             IQueryable<Orders> q = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);  
  3.             IEnumerable<Orders> e = db.Orders.OrderBy(x=>x.id).Skip(1).Take(2);  
  4.   
  5.             Console.WriteLine("IQueryable : \r\n"+q.ToString());  
  6.             Console.WriteLine("---------------------------------------------------------");  
  7.             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 ?
  1. SELECT TOP (2)   
  2. [Extent1].[id] AS [id],   
  3. [Extent1].[parentid] AS [parentid],   
  4. [Extent1].[code] AS [code]  
  5. 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]  
  6.     FROM [dbo].[Orders] AS [Extent1]  
  7. )  AS [Extent1]  
  8. WHERE [Extent1].[row_number] > 1  
  9. 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 
    ? 
   
 
  
 
  
     
   
  1. SELECT TOP (2)   
    2.  
   
  2. [Extent1].[id] AS [id],   
    3.  
   
  3. [Extent1].[parentid] AS [parentid],   
    4.  
   
  4. [Extent1].[code] AS [code]  
    5.  
   
  5. 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]  
    6.  
   
  6.     FROM [dbo].[Orders] AS [Extent1]  
    7.  
   
  7. )  AS [Extent1]  
    8.  
   
  8. WHERE [Extent1].[row_number] > 1  
    9.  
   
  9. ORDER BY [Extent1].[id] ASC  
    10.  
  
 
 
 
 
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 
    ? 
   
 
  
 
  
     
   
  1. TestDataEntities db = new TestDataEntities();  
    2.  
   
  2.             IQueryable<Orders> q = db.Orders.OrderBy(x => x.id).AsQueryable<Orders>().Skip(10).Take(2);  
    3.  
   
  3.             IEnumerable<Orders> e = db.Orders.OrderBy(x => x.id).AsEnumerable<Orders>().Skip(10).Take(2);  
    4.  
   
  4.   
    5.  
   
  5.             foreach (var item in q)  
    6.  
   
  6.             {  
    7.  
   
  7.                 Console.WriteLine("123");  
    8.  
   
  8.             }  
    9.  
   
  9.   
    10.  
   
  10.             foreach (var item in e)  
    11.  
   
  11.             {  
    12.  
   
  12.                 Console.WriteLine("234");  
    13.  
   
  13.             }  
    14.  
  
 
 
 
 
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 
    ? 
   
 
  
 
  
     
   
  1. SELECT TOP (2)   
    2.  
   
  2. [Extent1].[id] AS [id],   
    3.  
   
  3. [Extent1].[parentid] AS [parentid],   
    4.  
   
  4. [Extent1].[code] AS [code]  
    5.  
   
  5. 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]  
    6.  
   
  6. FROM [dbo].[Orders] AS [Extent1]  
    7.  
   
  7. )  AS [Extent1]  
    8.  
   
  8. WHERE [Extent1].[row_number] > 10  
    9.  
   
  9. ORDER BY [Extent1].[id] ASC  
    10.  
  
 
 
 
 
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 
    ? 
   
 
  
 
  
     
   
  1. SELECT   
    2.  
   
  2. [Extent1].[id] AS [id],   
    3.  
   
  3. [Extent1].[parentid] AS [parentid],   
    4.  
   
  4. [Extent1].[code] AS [code]  
    5.  
   
  5. FROM [dbo].[Orders] AS [Extent1]  
    6.  
   
  6. ORDER BY [Extent1].[id] ASC  
    7.  
  
 
 
 
 
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
 

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


        

            

        	





    

		

            
相關文章

            

                

                

                    

                

            


            
相關標籤/搜索

            
        


    

        

            

        

        

        
        

        

        

    




	

    





    

    	

    

        每日一句
    

    
    
    	每一个你不满意的现在，都有一个你没有努力的曾经。
    







    

    


    



    

        本站公眾號
    

    

           歡迎關注本站公眾號,獲取更多信息

        
    




    

    




	


	







    

        聯繫我們
        最近搜索
        最新文章
        
        沪ICP备13005482号-10

            MyBatis教程
            SQL 教程
            MySQL教程
            Java 教程
            Thymeleaf 教程
            Hibernate教程
            Spring教程 
            Redis教程