Paging in ASP.NET Web API

public class PagedResults<T>
{
    /// <summary>
    /// The page number this page represents. 
    /// </summary>
    public int PageNumber { get; set; } 
    
    /// <summary> 
    /// The size of this page. 
    /// </summary> 
    public int PageSize { get; set; } 
    
    /// <summary> 
    /// The total number of pages available. 
    /// </summary> 
    public int TotalNumberOfPages { get; set; } 
    
    /// <summary> 
    /// The total number of records available. 
    /// </summary> 
    public int TotalNumberOfRecords { get; set; } 
    
    /// <summary> 
    /// The URL to the next page - if null, there are no more pages. 
    /// </summary> 
    public string NextPageUrl { get; set; } 
    
    /// <summary> 
    /// The records this page represents. 
    /// </summary> 
    public IEnumerable<T> Results { get; set; } 
}

public class Employee
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public string SocialSecurityNumber { get; set; } //you probably don't want this returned by default, making the EmployeeModel useful
	public ICollection < Todo > TodoList { get; set; } = new List < Todo > ();
}

public class EmployeeModel
{
	public int Id { get; set; }
	public string FirstName { get; set; }
	public string LastName { get; set; }
	public ICollection<TodoModel> TodoList { get; set; }
}

public class Todo
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
	public Employee Employee { get; set; }
}

public class TodoModel
{
	public int Id { get; set; }
	public string Name { get; set; }
	public string Description { get; set; }
}

public class EntityContext : DbContext
{
	public virtual DbSet<Employee> Employees { get; set; }
	public virtual DbSet<Todo> Todos { get; set; }
}

Mapper.CreateMap<Employee, EmployeeModel>();
Mapper.CreateMap<Todo, TodoModel>();

public class EmployeesController : BaseController
{
    public EntityContext EntityContext { get; }
 
    protected EmployeesController(EntityContext context)
    {
        EntityContext = context;
    }
 
    public async Task<IHttpActionResult> Get(int? page = null, int pageSize = 10, string orderBy = nameof(Employee.Id), bool ascending = true)
    {
        if (page == null)
            return Ok(await EntityContext.Employees.ToListAsync());
 
        var employees = await CreatePagedResults<Employee, EmployeeModel>
            (EntityContext.Employees, page.Value, pageSize, orderBy, ascending);
        return Ok(employees);
    }
 
    /// <summary>
    /// Creates a paged set of results.
    /// </summary>
    /// <typeparam name="T">The type of the source IQueryable.</typeparam>
    /// <typeparam name="TReturn">The type of the returned paged results.</typeparam>
    /// <param name="queryable">The source IQueryable.</param>
    /// <param name="page">The page number you want to retrieve.</param>
    /// <param name="pageSize">The size of the page.</param>
    /// <param name="orderBy">The field or property to order by.</param>
    /// <param name="ascending">Indicates whether or not the order should be ascending (true) or descending (false.)</param>
    /// <returns>Returns a paged set of results.</returns>
    protected async Task<PagedResults<TReturn>> CreatePagedResults<T, TReturn>(
        IQueryable<T> queryable,
        int page,
        int pageSize,
        string orderBy,
        bool ascending)
    {
        var skipAmount = pageSize * (page - 1);
 
        var projection = queryable
            .OrderByPropertyOrField(orderBy, ascending)
            .Skip(skipAmount)
            .Take(pageSize).ProjectTo<TReturn>();
 
        var totalNumberOfRecords = await queryable.CountAsync();
        var results = await projection.ToListAsync();
 
        var mod = totalNumberOfRecords % pageSize;
        var totalPageCount = (totalNumberOfRecords / pageSize) + (mod == 0 ? 0 : 1);
 
            var nextPageUrl =
            page == totalPageCount
                ? null
                : Url?.Link("DefaultApi", new {
                    page = page + 1,
                    pageSize,
                    orderBy,
                    ascending
                });
 
        return new PagedResults<TReturn>
        {
            Results = results,
            PageNumber = page,
            PageSize = results.Count,
            TotalNumberOfPages = totalPageCount,
            TotalNumberOfRecords = totalNumberOfRecords,
            NextPageUrl = nextPageUrl
        };
    }
}

public static class Extensions
{
    /// <summary>
    /// Order the IQueryable by the given property or field.
    /// </summary>
 
    /// <typeparam name="T">The type of the IQueryable being ordered.</typeparam>
    /// <param name="queryable">The IQueryable being ordered.</param>
    /// <param name="propertyOrFieldName">The name of the property or field to order by.</param>
    /// <param name="ascending">Indicates whether or not the order should be ascending (true) or descending (false.)</param>
    /// <returns>Returns an IQueryable ordered by the specified field.</returns>
    public static IQueryable<T> OrderByPropertyOrField<T>(this IQueryable<T> queryable, string propertyOrFieldName, bool ascending = true)
    {
        var elementType = typeof (T);
        var orderByMethodName = ascending ? "OrderBy" : "OrderByDescending";
 
        var parameterExpression = Expression.Parameter(elementType);
        var propertyOrFieldExpression = Expression.PropertyOrField(parameterExpression, propertyOrFieldName);
        var selector = Expression.Lambda(propertyOrFieldExpression, parameterExpression);
 
        var orderByExpression = Expression.Call(typeof (Queryable), orderByMethodName,
            new[] {elementType, propertyOrFieldExpression.Type}, queryable.Expression, selector);
 
        return queryable.Provider.CreateQuery<T>(orderByExpression);
    }
}