SquaredRoot

Return of the PagedList

// June 15th, 2009 // 7 Comments » // C#, LINQ, MVC

It has been nearly a year since I posted an updated version of the PagedList<T> functionality originally created by Scott Guthrie and posted by Rob Conery. Since then I have used the class in a number of projects and find it indispensable.

A few days ago, Craig Stuntz reported an interesting observation: when the first page is returned, the class performs a Skip(0). Suprisingly, this is not free. With that in mind, I set out to correct that issue as well as incorporate a few changes I’ve made over the past year. The result is nearly identical to the last posted version, just a bit more readable. Additionally…
(more…)

PagedList Strikes Back

// July 8th, 2008 // 9 Comments » // C#

There is an updated version of the PagedList<T> code available here.

A few months ago I posted about my changes to Rob Conery’s PagedList class. Since writing that article many comments have been left about how to further improve the design, which I have since incorporated into a new, further improved PagedList class. For those who aren’t familiar, the PagedList class allows scenarios such as the following:

   1: public void ListProducts( int pageIndex )

   2: {

   3:     int pageSize = 10;

   4:     var products = productRepository.GetAllProducts()

   5:         .ToPagedList( pageIndex, pageSize );

   6:     return View( products );

   7: }

(more…)

Rob Conery’s PagedList Class (Updated)

// April 8th, 2008 // 13 Comments » // C#

NOTE:
A new, improved version of this class is now available at:

http://www.squaredroot.com/post/2008/07/08/PagedList-Strikes-Back.aspx

Robert Muehsig has posted a great user control for the MVC framework that adds pagination links to the bottom of a paged list. In it he used a slightly customized version of Rob Conery’s PagedList class that Rob was kind enough to post way back when the first CTP was released. This reminded me that I should probably post the version I have customized, as I think it makes it a bit easier to use and maintain. I’ve included the code below.

   1: using System;

   2: using System.Linq;

   3:  

   4: namespace System.Collections.Generic

   5: {

   6:  

   7:     public interface IPagedList

   8:     {

   9:         int TotalPages { get; }

  10:         int TotalCount { get; }

  11:         int PageIndex { get; }

  12:         int PageSize { get; }

  13:         bool HasPreviousPage { get; }

  14:         bool HasNextPage { get; }

  15:         bool IsFirstPage { get; }

  16:         bool IsLastPage { get; }

  17:     }

  18:  

  19:     public class PagedList<T> : List<T>, IPagedList

  20:     {

  21:  

  22:         public PagedList( IEnumerable<T> source, int index, int pageSize )

  23:         {

  24:  

  25:             //### set source to blank list if source is null to prevent exceptions

  26:             if( source == null )

  27:                 source = new List<T>();

  28:  

  29:             //### set properties

  30:             this.TotalCount = source.Count();

  31:             this.PageSize = pageSize;

  32:             this.PageIndex = index;

  33:             if( this.TotalCount > 0 )

  34:                 this.TotalPages = (int)Math.Ceiling( (double)this.TotalCount / (double)this.PageSize );

  35:             else

  36:                 this.TotalPages = 0;

  37:             this.HasPreviousPage = ( this.PageIndex > 1 );

  38:             this.HasNextPage = ( this.PageIndex < this.TotalPages );

  39:             this.IsFirstPage = ( this.PageIndex == 1 );

  40:             this.IsLastPage = ( this.PageIndex == this.TotalPages );

  41:  

  42:             //### argument checking

  43:             if( index < 1 || index > this.TotalPages )

  44:                 throw new ArgumentOutOfRangeException( "PageIndex out of range." );

  45:             if( pageSize < 1 )

  46:                 throw new ArgumentOutOfRangeException( "PageSize cannot be less than 1." );

  47:  

  48:             //### add items to internal list

  49:             if( this.TotalCount > 0 )

  50:                 this.AddRange( source.Skip( ( index - 1 ) * pageSize ).Take( pageSize ).ToList() );

  51:  

  52:         }

  53:  

  54:         public int TotalPages { get; private set; }

  55:         public int TotalCount { get; private set; }

  56:         public int PageIndex { get; private set; }

  57:         public int PageSize { get; private set; }

  58:         public bool HasPreviousPage { get; private set; }

  59:         public bool HasNextPage { get; private set; }

  60:         public bool IsFirstPage { get; private set; }

  61:         public bool IsLastPage { get; private set; }

  62:  

  63:     }

  64:  

  65:     public static class Pagination

  66:     {

  67:         public static PagedList<T> ToPagedList<T>( this IEnumerable<T> source, int index, int pageSize )

  68:         {

  69:             return new PagedList<T>( source, index, pageSize );

  70:         }

  71:     }

  72:  

  73: }

Changes from Rob’s version:

• Added a "TotalPages" property.
  
  If you’re going to loop through each of the pages to display page navigation, you’ll obviously need this.
• Changed "IsPreviousPage" to "HasPreviousPage".
  
  It just sounds better.
• Changed "IsNextPage" to "HasNextPage".
  
  See above.
• Added a "IsFirstPage" property.
  
  The opposite way of using the above two properties. I prefer this way, but kept the original way for backwards compatibility (except the naming).
• Added a "IsLastPage" property.
  
  See above.
• Changed the first constructor to accept IEnumerable<T> rather than IQueryable<T>.
  
  I’m not exactly sure why Rob originally made it IQueryable. I’m aware that by passing an IQueryable (LINQ) object to this constructor you’ll avoid retrieving the entire set (only taking the results needed), but since IQueryable inherits from IEnumerable everything should be hunky-dory. He probably had a reason and I’m going to wind up breaking all of my stuff, but IEnumerable is just so much handier. =)
• Removed the second constructor.
  
  The second constructor took List<T>, which is unnecessary after changing the first constructor to accept IEnumerable.
• Cleaned up property declarations a bit.
  
  Mainly to make the page a bit shorter, but also to prevent the multiple calculations that could happen in the original. Also the original allowed the changing of certain properties after an instance was created, which would put the instance into an inconsistent state.
• Added argument checking and handled a few exception scenarios more gracefully.
  
  Trying to make debugging a bit friendlier.
• Removed the second extension method that didn’t specify a pageSize.
  
  I don’t really think that baking in an extension method that sets pageSize to 10 is a good idea, I’d prefer pageSize to be explicitly set elsewhere by the calling code.
• Moved the code to the "System.Collections.Generic" namespace.
  
  I’m sure a lot of you are breaking out in a cold sweat to see me putting something into a System.* namespace, but I kind of feel like this is something that the .Net team just "forgot". =) Move it wherever makes you comfortable.

Please note that I took many of these ideas from the commentary below Rob’s original post. I’m sure many of you are using something similar, but I thought it would be useful to get something posted online that is a bit more fleshed out than the original example.

Thanks for the great work Rob & Robert!