Paging with LINQ for objects

Question

How would you implement paging in a LINQ query   Actually for the time being  I would be satisfied if the sql TOP function could be imitated  However  I am sure that the need for full paging support comes up sooner later anyway   var queryResult   from o in objects                   where                       select new                                                  A   o a                           B   o b                                                      TOP 10

User · Answer

Here is my performant approach to paging when using LINQ to objects:

public static IEnumerable<IEnumerable<T>> Page<T>(this IEnumerable<T> source, int pageSize)
{
    Contract.Requires(source != null);
    Contract.Requires(pageSize > 0);
    Contract.Ensures(Contract.Result<IEnumerable<IEnumerable<T>>>() != null);

    using (var enumerator = source.GetEnumerator())
    {
        while (enumerator.MoveNext())
        {
            var currentPage = new List<T>(pageSize)
            {
                enumerator.Current
            };

            while (currentPage.Count < pageSize && enumerator.MoveNext())
            {
                currentPage.Add(enumerator.Current);
            }
            yield return new ReadOnlyCollection<T>(currentPage);
        }
    }
}

This can then be used like so:

var items = Enumerable.Range(0, 12);

foreach(var page in items.Page(3))
{
    // Do something with each page
    foreach(var item in page)
    {
        // Do something with the item in the current page       
    }
}

None of this rubbish Skip and Take which will be highly inefficient if you are interested in multiple pages.

User · Answer

You re looking for the Skip and Take extension methods  Skip moves past the first N elements in the result  returning the remainder  Take returns the first N elements in the result  dropping any remaining elements   See MSDN for more information on how to use these methods  http   msdn microsoft com en-us library bb386988 aspx  Assuming you are already taking into account that the pageNumber should start at 0  decrease per 1 as suggested in the comments  You could do it like this   int numberOfObjectsPerPage   10  var queryResultPage   queryResult    Skip numberOfObjectsPerPage   pageNumber     Take numberOfObjectsPerPage     Otherwise as suggested by  Alvin  int numberOfObjectsPerPage   10  var queryResultPage   queryResult    Skip numberOfObjectsPerPage    pageNumber - 1      Take numberOfObjectsPerPage

User · Answer

Using Skip and Take is definitely the way to go  If I were implementing this  I would probably write my own extension method to handle paging  to make the code more readable   The implementation can of course use Skip and Take   static class PagingUtils     public static IEnumerable lt T gt  Page lt T gt  this IEnumerable lt T gt  en  int pageSize  int page        return en Skip page   pageSize  Take pageSize         public static IQueryable lt T gt  Page lt T gt  this IQueryable lt T gt  en  int pageSize  int page        return en Skip page   pageSize  Take pageSize           The class defines two extension methods - one for IEnumerable and one for IQueryable  which means that you can use it with both LINQ to Objects and LINQ to SQL  when writing database query  the compiler will pick the IQueryable version    Depending on your paging requirements  you could also add some additional behavior  for example to handle negative pageSize or page value   Here is an example how you would use this extension method in your query   var q    from p in products          where p Show    true          select new   p Name    Page 10  pageIndex

User · Answer

Don t know if this will help anyone  but I found it useful for my purposes   private static IEnumerable lt T gt  PagedIterator lt T gt  IEnumerable lt T gt  objectList  int PageSize        var page   0      var recordCount   objectList Count        var pageCount    int   recordCount   PageSize  PageSize        if  recordCount  lt  1                yield break             while  page  lt  pageCount                var pageData   objectList Skip PageSize page  Take PageSize  ToList             foreach  var rd in pageData                        yield return rd                    page              To use this you would have some linq query  and pass the result along with the page size into a foreach loop   var results   from a in dbContext Authors               where a PublishDate  gt  someDate               orderby a Publisher               select a   foreach var author in PagedIterator results  100            Do Stuff     So this will iterate over each author fetching 100 authors at a time

User · Answer

EDIT - Removed Skip 0  as it s not necessary  var queryResult    from o in objects where                           select new                                                   A   o a                            B   o b                                             Take 10

User · Answer

There are two main options    NET    4 0 Dynamic LINQ    Add using System Linq Dynamic  at the top  Use  var people   people AsQueryable   OrderBy  Make ASC  Year DESC   ToList      You can also get it by NuGet    NET  lt  4 0  Extension Methods   private static readonly Hashtable accessors   new Hashtable     private static readonly Hashtable callSites   new Hashtable     private static CallSite lt Func lt CallSite  object  object gt  gt  GetCallSiteLocked string name        var callSite    CallSite lt Func lt CallSite  object  object gt  gt  callSites name       if callSite    null                callSites name    callSite   CallSite lt Func lt CallSite  object  object gt  gt  Create                      Binder GetMember CSharpBinderFlags None  name  typeof AccessorCache                   new CSharpArgumentInfo     CSharpArgumentInfo Create CSharpArgumentInfoFlags None  null                 return callSite     internal static Func lt dynamic object gt  GetAccessor string name        Func lt dynamic  object gt  accessor    Func lt dynamic  object gt  accessors name       if  accessor    null                lock  accessors                         accessor    Func lt dynamic  object gt  accessors name               if  accessor    null                                if name IndexOf       gt   0                        string   props   name Split                           CallSite lt Func lt CallSite  object  object gt  gt    arr   Array ConvertAll props  GetCallSiteLocked                       accessor   target   gt                                                object val    object target                          for  int i   0  i  lt  arr Length  i                                                          var cs   arr i                               val   cs Target cs  val                                                     return val                                           else                       var callSite   GetCallSiteLocked name                       accessor   target   gt                                                return callSite Target callSite   object target                                                            accessors name    accessor                                    return accessor    public static IOrderedEnumerable lt dynamic gt  OrderBy this IEnumerable lt dynamic gt  source  string property        return Enumerable OrderBy lt dynamic  object gt  source  AccessorCache GetAccessor property   Comparer lt object gt  Default     public static IOrderedEnumerable lt dynamic gt  OrderByDescending this IEnumerable lt dynamic gt  source  string property        return Enumerable OrderByDescending lt dynamic  object gt  source  AccessorCache GetAccessor property   Comparer lt object gt  Default     public static IOrderedEnumerable lt dynamic gt  ThenBy this IOrderedEnumerable lt dynamic gt  source  string property        return Enumerable ThenBy lt dynamic  object gt  source  AccessorCache GetAccessor property   Comparer lt object gt  Default     public static IOrderedEnumerable lt dynamic gt  ThenByDescending this IOrderedEnumerable lt dynamic gt  source  string property        return Enumerable ThenByDescending lt dynamic  object gt  source  AccessorCache GetAccessor property   Comparer lt object gt  Default

User · Answer

I use this extension method   public static IQueryable lt T gt  Page lt T  TResult gt  this IQueryable lt T gt  obj  int page  int pageSize  System Linq Expressions Expression lt Func lt T  TResult gt  gt  keySelector  bool asc  out int rowsCount        rowsCount   obj Count        int innerRows   rowsCount -  page   pageSize       if  innerRows  lt  0                innerRows   0            if  asc          return obj OrderByDescending keySelector  Take innerRows  OrderBy keySelector  Take pageSize  AsQueryable        else         return obj OrderBy keySelector  Take innerRows  OrderByDescending keySelector  Take pageSize  AsQueryable       public IEnumerable lt Data gt  GetAll int RowIndex  int PageSize  string SortExpression        int totalRows      int pageIndex   RowIndex   PageSize       List lt Data gt  data  new List lt Data gt         IEnumerable lt Data gt  dataPage       bool asc    SortExpression Contains  DESC        switch  SortExpression Split      0                 case  ColumnName               dataPage   DataContext Data Page pageIndex  PageSize  p   gt  p ColumnName  asc  out totalRows               break          default              dataPage   DataContext vwClientDetails1s Page pageIndex  PageSize  p   gt  p IdColumn  asc  out totalRows               break             foreach  var d in dataPage                clients Add d              return data    public int CountAll         return DataContext Data Count

User · Answer

x000D   x000D  var results    medicineInfo OrderBy x  gt x id  x000D                          Skip  pages -1    2  x000D                          Take 2    x000D   x000D   x000D

User · Answer

public LightDataTable PagerSelection int pageNumber  int setsPerPage  Func lt LightDataRow  bool gt  prection   null                this setsPerPage   setsPerPage          this pageNumber   pageNumber  gt  0   pageNumber - 1   pageNumber          if   ValidatePagerByPageNumber pageNumber               return this           var rowList   rows Cast lt LightDataRow gt             if  prection    null              rowList   rows Where prection  ToList             if   rowList Any                return new LightDataTable     TablePrimaryKey   this tablePrimaryKey              if  rowList Count    lt   pageNumber   setsPerPage                 return new LightDataTable new LightDataRowCollection rowList     TablePrimaryKey   this tablePrimaryKey             return new LightDataTable new LightDataRowCollection rowList Skip this pageNumber   setsPerPage  Take setsPerPage  ToList       TablePrimaryKey   this tablePrimaryKey          this is what i did  Normaly you start at 1 but in IList you start with 0  so if you have 152 rows that mean you have 8 paging but in IList you only have 7  hop this can make thing clear for you

User · Answer

Similar to Lukazoid s answer I ve created an extension for IQueryable      public static IEnumerable lt IEnumerable lt T gt  gt  PageIterator lt T gt  this IQueryable lt T gt  source  int pageSize                                Contract Requires source    null                   Contract Requires pageSize  gt  0                   Contract Ensures Contract Result lt IEnumerable lt IQueryable lt T gt  gt  gt       null                    using  var enumerator   source GetEnumerator                                          while  enumerator MoveNext                                                  var currentPage   new List lt T gt  pageSize                                                        enumerator Current                                                     while  currentPage Count  lt  pageSize  amp  amp  enumerator MoveNext                                                          currentPage Add enumerator Current                                                     yield return new ReadOnlyCollection lt T gt  currentPage                                                           It is useful if Skip or Take are not supported

User · Answer

var pages   items Select  item  index    gt  new   item  Page   index   batchSize    GroupBy g   gt  g Page     Batchsize will obviously be an integer  This takes advantage of the fact that integers simply drop decimal places   I m half joking with this response  but it will do what you want it to  and because it s deferred  you won t incur a large performance penalty if you do  pages First p   gt  p Key    thePage    This solution is not for LinqToEntities  I don t even know if it could turn this into a good query

User · Answer

for o in objects     where         select new           A o a       B o b        Skip  page-1  pageSize   Take pageSize

[c#] Paging with LINQ for objects

Examples related to c#

Examples related to .net

Examples related to linq

Examples related to paging