MongoDB C#: पेजिनेशन के बारे में प्रश्न

Question

कुछ प्रश्नों के पेज किए गए परिणाम का उपयोग करने के लिए मुझे एक पृष्ठ एक बिंदु से प्राप्त करने की आवश्यकता है। ऑब्जेक्ट सही पृष्ठ पर स्थित डेटा लौटाता है जब आप पेज को खोलने के दायरे से बाहर बिंदु दबाते हैं परिणाम इस पृष्ठ पर।
यदि इस नमूने की तरह पेजेड परिणाम प्राप्त किया जा सकता है, तो मैं किस पृष्ठ से आने वाले आइटम से प्राप्त कर सकता हूं?

paging 
.skip(PAGE_SIZE * (PAGE_NUMBER - 1)).limit(PAGE_SIZE) 

    public List<BsonItem> GetData(QueryComplete query, int take, int skip, SortByBuilder sort) 
     { 
      var cursor = Db.Data.FindAs<BsonItem>(query); 

      if (skip > 0) 
       cursor.SetSkip(skip); 
      if (take > 0) 
       cursor.SetLimit(take); 
      if (sort != null) 
       cursor.SetSortOrder(sort); 
      return cursor.ToList(); 
     } 

आपकी सहायता के लिए धन्यवाद।

Answer 1

पृष्ठ संख्या (और संभव सॉर्ट ऑर्डर और दिशा) ग्राहक पक्ष से आनी चाहिए। तो ग्राहक कुछ पेज पर क्लिक करें और ..

व्यक्तिगत रूप से मैं किसी प्रकार का फ़िल्टर उपयोग करता हूं जिसमें आपको आवश्यक सभी गुण शामिल हैं।

उस फ़िल्टर का उपयोग करके आपको केवल उस पृष्ठ को निर्दिष्ट करने की आवश्यकता है जिसे आपको ग्रिड में प्रदर्शित करने की आवश्यकता है और आपको प्रति पृष्ठ कितनी वस्तुओं की आवश्यकता है।

var pageNumber = 1;// current page should come from the client 
var filter = new BaseFilter(){CurrentPage = pageNumber, ItemsPerPage = 30}; 
var items = GetItemsByFilter(filter, Query.LTE("SomeDate",DateTime.Now)), 
            SortBy.Ascending("SortField")); 
//For basic paging you only following three properties 
var totalCount = filter.TotalCount; // here will be total items count 
var pagesCount = filter.TotalPagesCount; // here will be total pages count 
// pageNumber = current page 

इसके अलावा आप बेसिकफिल्टर से अनुमान लगा सकते हैं और किसी भी गुण को जोड़ना चाहते हैं जो आपको क्वियरिंग, सॉर्टिंग के लिए आवश्यक है। यहाँ फिल्टर कोड (आशा है कि यह आप के लिए उपयोगी हो सकता है):

public List<Item> GetItemsByFilter(BaseFilter filter, 
        QueryComplete query, SortByBuilder sort) 
{ 
    var resultItems = new List<Item>(); 
    var cursor = Db.Data.FindAs<BsonItem>(query); 

    cursor.SetSortOrder(sort); 
    if (filter.IsNeedPaging) 
    { 
    cursor.SetSkip(filter.Skip).SetLimit(filter.Take); 
    filter.TotalCount = cursor.Count(); 
    } 

    resultItems.AddRange(cursor); 

    return resultItems; 
} 


public class BaseFilter 
{ 
    private int _itemsPerPage = 10; 
    private int _skip = 0; 
    private int _currentPage = 1; 

    public BaseFilter() 
    { 
    IsNeedPaging = true; 
    } 

    public int Skip 
    { 
    get 
    { 
     if (_skip == 0) 
     _skip = (CurrentPage - 1) * _itemsPerPage; 
     return _skip; 
    } 
    set 
    { 
     _skip = value; 
    } 
    } 

    public int Take 
    { 
    get 
     { 
     return _itemsPerPage; 
     } 
    set 
     { 
     _itemsPerPage = value; 
     } 
    } 

    public bool IsNeedPaging { get; set; } 

    public int TotalCount { get; set; } 

    public int CurrentPage 
    { 
     get 
     { 
      return _currentPage; 
     } 
     set 
     { 
      _currentPage = value; 
     } 
    } 

    public int ItemsPerPage 
    { 
     get 
     { 
      return _itemsPerPage; 
     } 
     set 
     { 
      _itemsPerPage = value; 
     } 
    } 

    public int TotalPagesCount 
    { 
     get 
     { 
      return TotalCount/ItemsPerPage + 
          ((TotalCount % ItemsPerPage > 0) ? 1 : 0); 
     } 
    } 
    }