diff --git a/src/DotNetToolkit.Repository/Queries/IQueryOptions.cs b/src/DotNetToolkit.Repository/Queries/IQueryOptions.cs
new file mode 100644
index 00000000..6e3f8604
--- /dev/null
+++ b/src/DotNetToolkit.Repository/Queries/IQueryOptions.cs
@@ -0,0 +1,18 @@
+namespace DotNetToolkit.Repository.Queries
+{
+    using System.Linq;
+
+    /// <summary>
+    /// Represents a query options which can be used for sorting or paging on queries.
+    /// </summary>
+    /// <typeparam name="T">The entity type of the repository.</typeparam>
+    public interface IQueryOptions<T>
+    {
+        /// <summary>
+        /// Applies the current options to the specified query.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The new query with the defined options applied.</returns>
+        IQueryable<T> Apply(IQueryable<T> query);
+    }
+}
diff --git a/src/DotNetToolkit.Repository/Queries/PagingOptions.cs b/src/DotNetToolkit.Repository/Queries/PagingOptions.cs
new file mode 100644
index 00000000..110097a5
--- /dev/null
+++ b/src/DotNetToolkit.Repository/Queries/PagingOptions.cs
@@ -0,0 +1,113 @@
+namespace DotNetToolkit.Repository.Queries
+{
+    using System;
+    using System.Linq;
+    using System.Linq.Expressions;
+
+    /// <summary>
+    /// Represents a paging option.
+    /// </summary>
+    /// <typeparam name="T">The entity type of the repository.</typeparam>
+    /// <typeparam name="TKey">The type of the property that is being sorted.</typeparam>
+    public class PagingOptions<T, TKey> : SortingOptions<T, TKey>
+    {
+        #region Fields
+
+        private const int DefaultPageSize = 100;
+        private int _pageIndex;
+        private int _pageSize;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the number of rows of the data page to retrieve.
+        /// </summary>
+        public int PageSize
+        {
+            get { return _pageSize; }
+            set
+            {
+                if (value <= 0)
+                    throw new ArgumentException($"{nameof(PageSize)} cannot be lower than zero.");
+
+                _pageSize = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the zero-based index of the data page to retrieve.
+        /// </summary>
+        public int PageIndex
+        {
+            get { return _pageIndex; }
+            set
+            {
+                if (value < 1)
+                    throw new ArgumentOutOfRangeException(nameof(PageIndex), "Cannot be lower than 1.");
+
+                _pageIndex = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets the page count.
+        /// </summary>
+        public int PageCount { get; private set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PagingOptions{TEntity, TKey}"/> class.
+        /// </summary>
+        /// <param name="pageIndex">The zero-based index of the data page to retrieve.</param>
+        /// <param name="sorting">The sorting expression.</param>
+        /// <param name="isDescending">if set to <c>true</c> use descending order; otherwise, use ascending.</param>
+        public PagingOptions(int pageIndex, Expression<Func<T, TKey>> sorting, bool isDescending = false) : base(sorting, isDescending)
+        {
+            PageIndex = pageIndex;
+            PageSize = DefaultPageSize;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PagingOptions{TEntity, TKey}"/> class.
+        /// </summary>
+        /// <param name="pageIndex">The zero-based index of the data page to retrieve.</param>
+        /// <param name="pageSize">The number of rows of the data page to retrieve.</param>
+        /// <param name="sorting">The sorting expression.</param>
+        /// <param name="isDescending">if set to <c>true</c> use descending order; otherwise, use ascending.</param>
+        public PagingOptions(int pageIndex, int pageSize, Expression<Func<T, TKey>> sorting, bool isDescending = false) : base(sorting, isDescending)
+        {
+            PageIndex = pageIndex;
+            PageSize = pageSize;
+        }
+
+        #endregion
+
+        #region Overrides of SortingOptions<TEntity,TKey>
+
+        /// <summary>
+        /// Applies the current options to the specified query.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The new query with the defined options applied.</returns>
+        public override IQueryable<T> Apply(IQueryable<T> query)
+        {
+            var pageCount = (int)Math.Ceiling(query.Count() / (decimal)PageSize);
+
+            if (PageIndex > pageCount)
+                throw new ArgumentOutOfRangeException(nameof(PageIndex), "Cannot be greater than the total number of pages.");
+
+            PageCount = pageCount;
+
+            query = base.Apply(query);
+
+            return query.Skip((PageIndex - 1) * PageSize).Take(PageSize);
+        }
+
+        #endregion
+    }
+}
diff --git a/src/DotNetToolkit.Repository/Queries/SortingOptions.cs b/src/DotNetToolkit.Repository/Queries/SortingOptions.cs
new file mode 100644
index 00000000..dc0cc27c
--- /dev/null
+++ b/src/DotNetToolkit.Repository/Queries/SortingOptions.cs
@@ -0,0 +1,69 @@
+namespace DotNetToolkit.Repository.Queries
+{
+    using System;
+    using System.Linq;
+    using System.Linq.Expressions;
+
+    /// <summary>
+    /// Represents a sorting option.
+    /// </summary>
+    /// <typeparam name="T">The entity type of the repository.</typeparam>
+    /// <typeparam name="TKey">The type of the property that is being sorted.</typeparam>
+    public class SortingOptions<T, TKey> : IQueryOptions<T>
+    {
+        #region Fields
+
+        private readonly Expression<Func<T, TKey>> _sorting;
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this sorting option is descending.
+        /// </summary>
+        /// <value>
+        /// <c>true</c> if this sorting option is descending; otherwise, <c>false</c>.
+        /// </value>
+        public bool IsDescending { get; set; }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SortingOptions{TEntity, TKey}"/> class.
+        /// </summary>
+        /// <param name="sorting">The sorting expression.</param>
+        /// <param name="isDescending">if set to <c>true</c> use descending order; otherwise, use ascending.</param>
+        public SortingOptions(Expression<Func<T, TKey>> sorting, bool isDescending = false)
+        {
+            _sorting = sorting;
+
+            IsDescending = isDescending;
+        }
+
+        #endregion
+
+        #region Implementation of IQueryOptions<T>
+
+        /// <summary>
+        /// Applies the current options to the specified query.
+        /// </summary>
+        /// <param name="query">The query.</param>
+        /// <returns>The new query with the defined options applied.</returns>
+        public virtual IQueryable<T> Apply(IQueryable<T> query)
+        {
+            if (_sorting != null)
+            {
+                query = IsDescending
+                    ? query.OrderByDescending(_sorting)
+                    : query.OrderBy(_sorting);
+            }
+
+            return query;
+        }
+
+        #endregion
+    }
+}
diff --git a/src/DotNetToolkit.Repository/RepositoryBase.cs b/src/DotNetToolkit.Repository/RepositoryBase.cs
index a98c5549..31b57f08 100644
--- a/src/DotNetToolkit.Repository/RepositoryBase.cs
+++ b/src/DotNetToolkit.Repository/RepositoryBase.cs
@@ -2,6 +2,7 @@
 {
     using FetchStrategies;
     using Helpers;
+    using Queries;
     using Specifications;
     using System;
     using System.Collections.Generic;
@@ -62,13 +63,13 @@ protected virtual IQueryable<TEntity> AsQueryable()
         /// </summary>
         protected virtual TEntity GetQuery(TKey key, IFetchStrategy<TEntity> fetchStrategy)
         {
-            return (TEntity)GetQuery(ByPrimaryKeySpecification(key, fetchStrategy));
+            return GetQuery(ByPrimaryKeySpecification(key, fetchStrategy));
         }
 
         /// <summary>
         /// Gets an entity query with the given primary key value from the repository.
         /// </summary>
-        protected virtual TEntity GetQuery(TKey key)
+        protected TEntity GetQuery(TKey key)
         {
             return Get(key, (IFetchStrategy<TEntity>)null);
         }
@@ -76,23 +77,40 @@ protected virtual TEntity GetQuery(TKey key)
         /// <summary>
         /// Gets an entity query that satisfies the criteria specified by the <paramref name="criteria" /> from the repository.
         /// </summary>
-        protected virtual IQueryable<TEntity> GetQuery(ISpecification<TEntity> criteria)
+        protected TEntity GetQuery(ISpecification<TEntity> criteria)
+        {
+            var query = GetQuery(criteria.FetchStrategy);
+
+            return criteria.SatisfyingEntityFrom(query);
+        }
+
+        /// <summary>
+        /// Gets an entity query that satisfies the criteria specified by the <paramref name="criteria" /> from the repository.
+        /// </summary>
+        protected IQueryable<TEntity> GetQuery(ISpecification<TEntity> criteria, IQueryOptions<TEntity> options)
         {
             if (criteria == null)
                 throw new ArgumentNullException(nameof(criteria));
 
-            return GetQuery(criteria.FetchStrategy);
+            var query = GetQuery(criteria.FetchStrategy);
+
+            query = criteria.SatisfyingEntitiesFrom(query);
+
+            if (options != null)
+                query = options.Apply(query);
+
+            return query;
         }
 
         /// <summary>
         /// Gets an entity query that satisfies the criteria specified by the <paramref name="predicate" /> from the repository.
         /// </summary>
-        protected virtual IQueryable<TEntity> GetQuery(Expression<Func<TEntity, bool>> predicate)
+        protected IQueryable<TEntity> GetQuery(Expression<Func<TEntity, bool>> predicate, IQueryOptions<TEntity> options)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return GetQuery(new Specification<TEntity>(predicate));
+            return GetQuery(new Specification<TEntity>(predicate), options);
         }
 
         /// <summary>
@@ -134,7 +152,7 @@ protected virtual ISpecification<TEntity> ByPrimaryKeySpecification(TKey key, IF
         /// <returns>The number of entities contained in the repository.</returns>
         public int Count()
         {
-            return GetQuery().Count();
+            return Count((ISpecification<TEntity>)null);
         }
 
         /// <summary>
@@ -144,7 +162,9 @@ public int Count()
         /// <returns>The number of entities that satisfied the criteria specified by the <paramref name="criteria" /> in the repository.</returns>
         public int Count(ISpecification<TEntity> criteria)
         {
-            return GetQuery(criteria).Count();
+            var predicate = criteria?.Predicate?.Compile();
+
+            return predicate == null ? GetQuery().Count() : GetQuery().Count(predicate);
         }
 
         /// <summary>
@@ -154,7 +174,7 @@ public int Count(ISpecification<TEntity> criteria)
         /// <returns>The number of entities that satisfied the criteria specified by the <paramref name="predicate" /> in the repository.</returns>
         public int Count(Expression<Func<TEntity, bool>> predicate)
         {
-            return GetQuery(predicate == null ? null : new Specification<TEntity>(predicate)).Count();
+            return Count(predicate == null ? null : new Specification<TEntity>(predicate));
         }
 
         #endregion
@@ -390,26 +410,28 @@ public bool Exists(TKey key)
         /// Finds the first entity in the repository that satisfies the criteria specified by the <paramref name="predicate" /> in the repository.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The entity that satisfied the criteria specified by the <paramref name="predicate" /> in the repository.</returns>
-        public TEntity Find(Expression<Func<TEntity, bool>> predicate)
+        public TEntity Find(Expression<Func<TEntity, bool>> predicate, IQueryOptions<TEntity> options = null)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return GetQuery(predicate).FirstOrDefault();
+            return GetQuery(predicate, options).FirstOrDefault();
         }
 
         /// <summary>
         /// Finds the first entity in the repository that satisfies the criteria specified by the <paramref name="criteria" /> in the repository.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The entity that satisfied the criteria specified by the <paramref name="criteria" /> in the repository.</returns>
-        public TEntity Find(ISpecification<TEntity> criteria)
+        public TEntity Find(ISpecification<TEntity> criteria, IQueryOptions<TEntity> options = null)
         {
             if (criteria == null)
                 throw new ArgumentNullException(nameof(criteria));
 
-            return GetQuery(criteria).FirstOrDefault();
+            return GetQuery(criteria, options).FirstOrDefault();
         }
 
         /// <summary>
@@ -417,8 +439,9 @@ public TEntity Find(ISpecification<TEntity> criteria)
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The projected entity result that satisfied the criteria specified by the <paramref name="selector" /> in the repository.</returns>
-        public TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector)
+        public TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
@@ -426,7 +449,7 @@ public TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expressi
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return GetQuery(predicate).Select(selector).FirstOrDefault();
+            return GetQuery(predicate, options).Select(selector).FirstOrDefault();
         }
 
         /// <summary>
@@ -434,8 +457,9 @@ public TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expressi
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The projected entity result that satisfied the criteria specified by the <paramref name="selector" /> in the repository.</returns>
-        public TResult Find<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector)
+        public TResult Find<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null)
         {
             if (criteria == null)
                 throw new ArgumentNullException(nameof(criteria));
@@ -443,33 +467,35 @@ public TResult Find<TResult>(ISpecification<TEntity> criteria, Expression<Func<T
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return GetQuery(criteria).Select(selector).FirstOrDefault();
+            return GetQuery(criteria, options).Select(selector).FirstOrDefault();
         }
 
         /// <summary>
         /// Finds the collection of entities in the repository that satisfied the criteria specified by the <paramref name="predicate" />.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of entities in the repository that satisfied the criteria specified by the <paramref name="predicate" />.</returns>
-        public IEnumerable<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate)
+        public IEnumerable<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate, IQueryOptions<TEntity> options = null)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
 
-            return GetQuery(predicate).ToList();
+            return GetQuery(predicate, options).ToList();
         }
 
         /// <summary>
         /// Finds the collection of entities in the repository that satisfied the criteria specified by the <paramref name="criteria" />.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of entities in the repository that satisfied the criteria specified by the <paramref name="criteria" />.</returns>
-        public IEnumerable<TEntity> FindAll(ISpecification<TEntity> criteria)
+        public IEnumerable<TEntity> FindAll(ISpecification<TEntity> criteria, IQueryOptions<TEntity> options = null)
         {
             if (criteria == null)
                 throw new ArgumentNullException(nameof(criteria));
 
-            return GetQuery(criteria).ToList();
+            return GetQuery(criteria, options).ToList();
         }
 
         /// <summary>
@@ -477,8 +503,9 @@ public IEnumerable<TEntity> FindAll(ISpecification<TEntity> criteria)
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="predicate" />.</returns>
-        public IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector)
+        public IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null)
         {
             if (predicate == null)
                 throw new ArgumentNullException(nameof(predicate));
@@ -486,7 +513,7 @@ public IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> pre
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return GetQuery(predicate).Select(selector).ToList();
+            return GetQuery(predicate, options).Select(selector).ToList();
         }
 
         /// <summary>
@@ -494,8 +521,9 @@ public IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> pre
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="criteria" />.</returns>
-        public IEnumerable<TResult> FindAll<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector)
+        public IEnumerable<TResult> FindAll<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null)
         {
             if (criteria == null)
                 throw new ArgumentNullException(nameof(criteria));
@@ -503,7 +531,7 @@ public IEnumerable<TResult> FindAll<TResult>(ISpecification<TEntity> criteria, E
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            return GetQuery(criteria).Select(selector).ToList();
+            return GetQuery(criteria, options).Select(selector).ToList();
         }
 
         /// <summary>
diff --git a/src/DotNetToolkit.Repository/Traits/ICanFind.cs b/src/DotNetToolkit.Repository/Traits/ICanFind.cs
index a2b4ebb0..72f1b1e2 100644
--- a/src/DotNetToolkit.Repository/Traits/ICanFind.cs
+++ b/src/DotNetToolkit.Repository/Traits/ICanFind.cs
@@ -1,5 +1,6 @@
 namespace DotNetToolkit.Repository.Traits
 {
+    using Queries;
     using Specifications;
     using System;
     using System.Collections.Generic;
@@ -15,61 +16,69 @@ public interface ICanFind<TEntity> where TEntity : class
         /// Finds the first entity in the repository that satisfies the criteria specified by the <paramref name="predicate" /> in the repository.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The entity that satisfied the criteria specified by the <paramref name="predicate" /> in the repository.</returns>
-		TEntity Find(Expression<Func<TEntity, bool>> predicate);
+		TEntity Find(Expression<Func<TEntity, bool>> predicate, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the first entity in the repository that satisfies the criteria specified by the <paramref name="criteria" /> in the repository.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The entity that satisfied the criteria specified by the <paramref name="criteria" /> in the repository.</returns>
-        TEntity Find(ISpecification<TEntity> criteria);
+        TEntity Find(ISpecification<TEntity> criteria, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the first projected entity result in the repository that satisfies the criteria specified by the <paramref name="predicate" /> in the repository.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The projected entity result that satisfied the criteria specified by the <paramref name="selector" /> in the repository.</returns>
-        TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector);
+        TResult Find<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the first projected entity result in the repository that satisfies the criteria specified by the <paramref name="criteria" /> in the repository.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The projected entity result that satisfied the criteria specified by the <paramref name="selector" /> in the repository.</returns>
-        TResult Find<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector);
+        TResult Find<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the collection of entities in the repository that satisfied the criteria specified by the <paramref name="predicate" />.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of entities in the repository that satisfied the criteria specified by the <paramref name="predicate" />.</returns>
-        IEnumerable<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate);
+        IEnumerable<TEntity> FindAll(Expression<Func<TEntity, bool>> predicate, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the collection of entities in the repository that satisfied the criteria specified by the <paramref name="criteria" />.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of entities in the repository that satisfied the criteria specified by the <paramref name="criteria" />.</returns>
-        IEnumerable<TEntity> FindAll(ISpecification<TEntity> criteria);
+        IEnumerable<TEntity> FindAll(ISpecification<TEntity> criteria, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="predicate" />.
         /// </summary>
         /// <param name="predicate">A function to filter each entity.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="predicate" />.</returns>
-        IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector);
+        IEnumerable<TResult> FindAll<TResult>(Expression<Func<TEntity, bool>> predicate, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Finds the collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="criteria" />.
         /// </summary>
         /// <param name="criteria">The specification criteria that is used for matching entities against.</param>
         /// <param name="selector">A function to project each entity into a new form.</param>
+        /// <param name="options">The options to apply to the query.</param>
         /// <returns>The collection of projected entity results in the repository that satisfied the criteria specified by the <paramref name="criteria" />.</returns>
-        IEnumerable<TResult> FindAll<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector);
+        IEnumerable<TResult> FindAll<TResult>(ISpecification<TEntity> criteria, Expression<Func<TEntity, TResult>> selector, IQueryOptions<TEntity> options = null);
 
         /// <summary>
         /// Determines whether the repository contains an entity that match the conditions defined by the specified by the <paramref name="predicate" />.
diff --git a/test/DotNetToolkit.Repository.Integration.Test/EfRepositoryTests.cs b/test/DotNetToolkit.Repository.Integration.Test/EfRepositoryTests.cs
index 40e7b82d..d13199fc 100644
--- a/test/DotNetToolkit.Repository.Integration.Test/EfRepositoryTests.cs
+++ b/test/DotNetToolkit.Repository.Integration.Test/EfRepositoryTests.cs
@@ -2,8 +2,10 @@
 {
     using Data;
     using EntityFramework;
+    using Queries;
     using Specifications;
     using System.Collections.Generic;
+    using System.Linq;
     using Xunit;
 
     public class EfRepositoryTests
@@ -177,6 +179,64 @@ public void Find()
             }
         }
 
+        [Fact]
+        public void Find_With_Sorting_Options_Ascending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>
+                {
+                    new Customer { Name = "Random Name 2" },
+                    new Customer { Name = "Random Name 1" }
+                };
+
+                var spec = new Specification<Customer>(x => x.Name.Contains("Random Name"));
+                var queryOptions = new SortingOptions<Customer, string>(x => x.Name, true);
+                var repo = new EfRepository<Customer>(context);
+
+                Assert.Null(repo.Find(x => x.Name.Contains("Random Name"), queryOptions)?.Name);
+                Assert.Null(repo.Find(spec, queryOptions)?.Name);
+                Assert.Null(repo.Find<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions));
+                Assert.Null(repo.Find<string>(spec, x => x.Name, queryOptions));
+
+                repo.Add(entities);
+
+                Assert.Equal("Random Name 2", repo.Find(x => x.Name.Contains("Random Name"), queryOptions).Name);
+                Assert.Equal("Random Name 2", repo.Find(spec, queryOptions).Name);
+                Assert.Equal("Random Name 2", repo.Find<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions));
+                Assert.Equal("Random Name 2", repo.Find<string>(spec, x => x.Name, queryOptions));
+            }
+        }
+
+        [Fact]
+        public void Find_With_Sorting_Options_Descending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>
+                {
+                    new Customer { Name = "Random Name 2" },
+                    new Customer { Name = "Random Name 1" }
+                };
+
+                var spec = new Specification<Customer>(x => x.Name.Contains("Random Name"));
+                var queryOptions = new SortingOptions<Customer, string>(x => x.Name);
+                var repo = new EfRepository<Customer>(context);
+
+                Assert.Null(repo.Find(x => x.Name.Contains("Random Name"), queryOptions)?.Name);
+                Assert.Null(repo.Find(spec, queryOptions)?.Name);
+                Assert.Null(repo.Find<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions));
+                Assert.Null(repo.Find<string>(spec, x => x.Name, queryOptions));
+
+                repo.Add(entities);
+
+                Assert.Equal("Random Name 1", repo.Find(x => x.Name.Contains("Random Name"), queryOptions).Name);
+                Assert.Equal("Random Name 1", repo.Find(spec, queryOptions).Name);
+                Assert.Equal("Random Name 1", repo.Find<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions));
+                Assert.Equal("Random Name 1", repo.Find<string>(spec, x => x.Name, queryOptions));
+            }
+        }
+
         [Fact]
         public void FindAll()
         {
@@ -202,6 +262,200 @@ public void FindAll()
             }
         }
 
+        [Fact]
+        public void FindAll_With_Sorting_Options_Ascending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>
+                {
+                    new Customer { Name = "Random Name 2" },
+                    new Customer { Name = "Random Name 1" }
+                };
+
+                var spec = new Specification<Customer>(x => x.Name.Contains("Random Name"));
+                var queryOptions = new SortingOptions<Customer, string>(x => x.Name, true);
+                var repo = new EfRepository<Customer>(context);
+
+                Assert.Null(repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions).FirstOrDefault()?.Name);
+                Assert.Null(repo.FindAll(spec, queryOptions).FirstOrDefault()?.Name);
+                Assert.Null(repo.FindAll<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions).FirstOrDefault());
+                Assert.Null(repo.FindAll<string>(spec, x => x.Name, queryOptions).FirstOrDefault());
+
+                repo.Add(entities);
+
+                Assert.Equal("Random Name 2", repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions).First().Name);
+                Assert.Equal("Random Name 2", repo.FindAll(spec, queryOptions).First().Name);
+                Assert.Equal("Random Name 2", repo.FindAll<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions).First());
+                Assert.Equal("Random Name 2", repo.FindAll<string>(spec, x => x.Name, queryOptions).First());
+            }
+        }
+
+        [Fact]
+        public void FindAll_With_Sorting_Options_Descending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>
+                {
+                    new Customer { Name = "Random Name 2" },
+                    new Customer { Name = "Random Name 1" }
+                };
+
+                var spec = new Specification<Customer>(x => x.Name.Contains("Random Name"));
+                var queryOptions = new SortingOptions<Customer, string>(x => x.Name);
+                var repo = new EfRepository<Customer>(context);
+
+                Assert.Null(repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions).FirstOrDefault()?.Name);
+                Assert.Null(repo.FindAll(spec, queryOptions).FirstOrDefault()?.Name);
+                Assert.Null(repo.FindAll<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions).FirstOrDefault());
+                Assert.Null(repo.FindAll<string>(spec, x => x.Name, queryOptions).FirstOrDefault());
+
+                repo.Add(entities);
+
+                Assert.Equal("Random Name 1", repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions).First().Name);
+                Assert.Equal("Random Name 1", repo.FindAll(spec, queryOptions).First().Name);
+                Assert.Equal("Random Name 1", repo.FindAll<string>(x => x.Name.Contains("Random Name"), x => x.Name, queryOptions).First());
+                Assert.Equal("Random Name 1", repo.FindAll<string>(spec, x => x.Name, queryOptions).First());
+            }
+        }
+
+        [Fact]
+        public void FindAll_With_Paging_Options_Sort_Ascending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>();
+
+                for (var i = 0; i < 21; i++)
+                {
+                    entities.Add(new Customer { Name = "Random Name " + i });
+                }
+
+                var repo = new EfRepository<Customer>(context);
+
+                repo.Add(entities);
+
+                var queryOptions = new PagingOptions<Customer, int>(1, 5, x => x.Id);
+                var entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 0", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 1", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 2", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 3", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 4", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 2;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 5", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 6", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 7", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 8", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 9", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 3;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 10", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 11", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 12", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 13", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 14", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 4;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 15", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 16", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 17", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 18", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 19", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 5;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Single(entitiesInDb);
+                Assert.Equal("Random Name 20", entitiesInDb.ElementAt(0).Name);
+            }
+        }
+
+        [Fact]
+        public void FindAll_With_Paging_Options_Sort_Descending()
+        {
+            using (var context = TestDbContextFactory.Create())
+            {
+                var entities = new List<Customer>();
+
+                for (var i = 0; i < 21; i++)
+                {
+                    entities.Add(new Customer { Name = "Random Name " + i });
+                }
+
+                var repo = new EfRepository<Customer>(context);
+
+                repo.Add(entities);
+
+                var queryOptions = new PagingOptions<Customer, int>(1, 5, x => x.Id, true);
+                var entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 20", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 19", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 18", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 17", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 16", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 2;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 15", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 14", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 13", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 12", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 11", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 3;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 10", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 9", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 8", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 7", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 6", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 4;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Equal(5, entitiesInDb.Count());
+                Assert.Equal("Random Name 5", entitiesInDb.ElementAt(0).Name);
+                Assert.Equal("Random Name 4", entitiesInDb.ElementAt(1).Name);
+                Assert.Equal("Random Name 3", entitiesInDb.ElementAt(2).Name);
+                Assert.Equal("Random Name 2", entitiesInDb.ElementAt(3).Name);
+                Assert.Equal("Random Name 1", entitiesInDb.ElementAt(4).Name);
+
+                queryOptions.PageIndex = 5;
+
+                entitiesInDb = repo.FindAll(x => x.Name.Contains("Random Name"), queryOptions);
+
+                Assert.Single(entitiesInDb);
+                Assert.Equal("Random Name 0", entitiesInDb.ElementAt(0).Name);
+            }
+        }
+
         [Fact]
         public void Get()
         {
diff --git a/test/DotNetToolkit.Repository.Test/PagingOptionsTests.cs b/test/DotNetToolkit.Repository.Test/PagingOptionsTests.cs
new file mode 100644
index 00000000..b274d2c9
--- /dev/null
+++ b/test/DotNetToolkit.Repository.Test/PagingOptionsTests.cs
@@ -0,0 +1,133 @@
+namespace DotNetToolkit.Repository.Test
+{
+    using Data;
+    using Queries;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Xunit;
+
+    public class PagingOptionsTests
+    {
+        [Fact]
+        public void Page_With_Sort__Ascending()
+        {
+            var entities = new List<Customer>();
+
+            for (var i = 0; i < 21; i++)
+            {
+                entities.Add(new Customer { Id = i, Name = "Random Name " + i });
+            }
+
+            var queryOptions = new PagingOptions<Customer, int>(1, 5, x => x.Id);
+            var queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 0", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 1", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 2", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 3", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 4", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 2;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 5", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 6", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 7", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 8", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 9", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 3;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 10", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 11", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 12", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 13", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 14", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 4;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 15", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 16", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 17", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 18", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 19", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 5;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Single(queryable);
+            Assert.Equal("Random Name 20", queryable.ElementAt(0).Name);
+        }
+
+        [Fact]
+        public void Page_With_Sort_Descending()
+        {
+            var entities = new List<Customer>();
+
+            for (var i = 0; i < 21; i++)
+            {
+                entities.Add(new Customer { Id = i, Name = "Random Name " + i });
+            }
+
+            var queryOptions = new PagingOptions<Customer, int>(1, 5, x => x.Id, true);
+            var queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 20", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 19", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 18", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 17", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 16", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 2;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 15", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 14", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 13", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 12", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 11", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 3;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 10", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 9", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 8", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 7", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 6", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 4;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal(5, queryable.Count());
+            Assert.Equal("Random Name 5", queryable.ElementAt(0).Name);
+            Assert.Equal("Random Name 4", queryable.ElementAt(1).Name);
+            Assert.Equal("Random Name 3", queryable.ElementAt(2).Name);
+            Assert.Equal("Random Name 2", queryable.ElementAt(3).Name);
+            Assert.Equal("Random Name 1", queryable.ElementAt(4).Name);
+
+            queryOptions.PageIndex = 5;
+
+            queryable = queryOptions.Apply(entities.AsQueryable());
+
+            Assert.Single(queryable);
+            Assert.Equal("Random Name 0", queryable.ElementAt(0).Name);
+        }
+    }
+}
diff --git a/test/DotNetToolkit.Repository.Test/SortingOptionsTests.cs b/test/DotNetToolkit.Repository.Test/SortingOptionsTests.cs
new file mode 100644
index 00000000..5f6f826c
--- /dev/null
+++ b/test/DotNetToolkit.Repository.Test/SortingOptionsTests.cs
@@ -0,0 +1,45 @@
+namespace DotNetToolkit.Repository.Test
+{
+    using Data;
+    using Queries;
+    using System.Collections.Generic;
+    using System.Linq;
+    using Xunit;
+
+    public class SortingOptionsTests
+    {
+        [Fact]
+        public void Descending_Sort()
+        {
+            var entities = new List<Customer>();
+            for (var i = 10; i >= 1; i--)
+            {
+                entities.Add(new Customer { Name = "Random Name " + i });
+            }
+
+            var sortingOptions = new SortingOptions<Customer, string>(x => x.Name);
+            var queryable = sortingOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal("Random Name 1", queryable.First().Name);
+
+            Assert.Equal(10, queryable.Count());
+        }
+
+        [Fact]
+        public void Ascending_Sort()
+        {
+            var entities = new List<Customer>();
+            for (var i = 10; i >= 1; i--)
+            {
+                entities.Add(new Customer { Name = "Random Name " + i });
+            }
+
+            var sortingOptions = new SortingOptions<Customer, string>(x => x.Name, true);
+            var queryable = sortingOptions.Apply(entities.AsQueryable());
+
+            Assert.Equal("Random Name 9", queryable.First().Name);
+
+            Assert.Equal(10, queryable.Count());
+        }
+    }
+}