Optimization Proposal - Reusing the query of specification

For pagination, i need to get the total number records before applying the pagination. So, i do not want the query rebuilt each time; for counting the total number of records and fetching the records for the current page. Thus, i designated the EfRepository.ListForPaging. What do you think about it?

public abstract class BaseSpecification<T> : ISpecification<T>
{
    public bool IsPagingEnabled { get; set; } // It is modifiable.
}

public class SpecificationEvaluator<T> where T : BaseEntity
{
  public static IQueryable<T> ApplyPaging(IQueryable<T> inputQuery, ISpecification<T> specification)
  {
      return inputQuery.Skip(specification.Skip).Take(specification.Take);
  }
}
public class EfRepository<T> : IRepository<T>, IAsyncRepository<T> where T : BaseEntity
{
  // TotalCount: Total count of records before paging applied.
  // List: List of records after paging applied.
  public (int totalCount, IEnumerable<T> list) ListForPaging(ISpecification<T> spec)
  {
      // Disable paging to get total count.
      spec.IsPagingEnabled = false;
      var query = ApplySpecification(spec);
      // Get count through query, not specification.
      var totalCount = query.Count();
      // Paging is applied to the existing query so rebuilding the query is eliminated.
      var list = SpecificationEvaluator<T>.ApplyPaging(query, spec).AsEnumerable();

      return (totalCount, list);
  }
}

Usage

var filterSpecification = new CategoryFilterPaginatedSpecification(pageIndex, itemsPerPage, queryConstraints);
var (filteredCount, list) = _categoryRepository.ListForPaging(filterSpecification);

[fiseni]

I read your comments once again. Obviously, your concern is building the query twice, not the the round trip to DB. Building the query (as it is done here), is just an in-memory process, and won’t affect too much. But, in some super large apps yea it might have an impact. I got your point, I just have few notes

• The method should be async (we should use .CountAsync() instead of Count()). The IRepository is not used anymore.
• AsEnumerable() is a generic method for casting only. It’s OK, but if used upon IQueryable, then the query won’t be processed at that moment. Instead, it will happen at the caller side, and depending how the results are used, some unexpected errors might occur (e.g. if result is used directly to iterate in for, foreach…).
• Built in tuples are available only in C# 7. I don’t know the audience of the project, but folks using VS 2015 might need additional customization in their environment.

[efleming18]

@expressiveco I don’t see why that would be a problem in terms of general architecture or OOP! 😃