विधि 'छोड़ें' केवल LINQ से इकाइयों में क्रमबद्ध इनपुट के लिए समर्थित है

Question

इस समस्या का कारण क्या हो सकता है?

public ActionResult Index(int page = 0) 
{ 
    const int pageSize = 3; 
    var areas = repo.FindAllAreas(); 
    var paginatedArea = new PaginatedList<Area>(areas, page, pageSize); 

    return View(paginatedArea); 
} 


using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 

namespace UTEPSA.Controllers 
{ 
    class PaginatedList<T> : List<T> 
    { 
     public int PageIndex { get; private set; } 
     public int PageSize { get; private set; } 
     public int TotalCount { get; private set; } 
     public int TotalPages { get; private set; } 
     public PaginatedList(IQueryable<T> source, int pageIndex, int pageSize) 
     { 
      PageIndex = pageIndex; 
      PageSize = pageSize; 
      TotalCount = source.Count(); 
      TotalPages = (int)Math.Ceiling(TotalCount/(double)PageSize); 
//ERROR HERE->>this.AddRange(source.Skip(PageIndex * PageSize).Take(PageSize)); 
     } 
     public bool HasPreviousPage 
     { 
      get 
      { 
       return (PageIndex > 0); 
      } 
     } 
     public bool HasNextPage 
     { 
      get 
      { 
       return (PageIndex + 1 < TotalPages); 
      } 
     } 
    } 
} 

कोई सुझाव?

Answer 1

ऐसा लगता है कि त्रुटि ठीक है जो कहती है। "छोड़ें केवल क्रमबद्ध इनपुट पर अनुमति है"। इस त्रुटि के लिए सर्च कर रहे हैं, मैंने पाया इस:

http://weblogs.asp.net/rajbk/archive/2009/09.aspx

यह तय किया जाना चाहिए अगर आप छोड़ें से पहले एक OrderBy में शामिल हैं:

source.orderBy(???).Skip(PageIndex * PageSize).Take(PageSize)); 

जब से तुम एक सामान्य से गुजर रहे हैं जो एक समस्या हो सकती है ऑब्जेक्ट टी। तत्व द्वारा ऑर्डर इंगित करने के लिए आपको एक और पैरामीटर प्राप्त करने के लिए अपनी कक्षा का विस्तार करने की आवश्यकता हो सकती है।

मुझे उम्मीद है कि इससे मदद मिलती है।

Answer 2

एक IQueryable में कोई ऑर्डर नहीं है, इसलिए कहें "अगले x तत्वों को अनदेखा करें" कोई अर्थ नहीं है।

आप एक order by खंड (या संभवतः एक AsEnumerable() कॉल - अपरीक्षित) शामिल हैं, तो आपके डेटा एक आदेश लेता है और Skip और Take अब समझदार हैं।

Answer 3

कि काम किया जाता है (पहले IOrderedQueryable का उपयोग करें):

http://msdn.microsoft.com/en-us/library/bb738702.aspx

IOrderedQueryable<Product> products = context.Products 
     .OrderBy(p => p.ListPrice); 

IQueryable<Product> allButFirst3Products = products.Skip(3); 

Console.WriteLine("All but first 3 products:"); 
foreach (Product product in allButFirst3Products) 
{ 
    Console.WriteLine("Name: {0} \t ID: {1}", 
     product.Name, 
     product.ProductID); 
} 

Answer 4

मैं एक ऐसी ही LINQ की एसक्यूएल बराबर चल छोड़/क्वेरी लेने के द्वारा इस मान्य करने के लिए करना चाहता था।

SELECT * FROM [table] 
--order by [column] //omitted! 
OFFSET 10 ROWS 
FETCH NEXT 15 rows only 

ध्यान दें कि जब आदेश-खंड छोड़ दिया जाता है, एसक्यूएल त्रुटि बहुत कम जानकारीपूर्ण है:

"Invalid usage of the option NEXT in the FETCH statement." 

तो "क्रमबद्ध इनपुट" वास्तव में डेटाबेस-स्तर पर आवश्यक है। डेवलपर्स को उन्नत एसक्यूएल स्टेटमेंट लिखने में मदद करने के लिए LINQ के लिए Kudos!