diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..a05b287
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,4 @@
+[*.cs]
+
+# IDE0011: Add braces
+csharp_prefer_braces = when_multiline
diff --git a/Paginator.sln b/Paginator.sln
index 5c9b300..c051370 100644
--- a/Paginator.sln
+++ b/Paginator.sln
@@ -5,10 +5,11 @@ VisualStudioVersion = 16.0.29006.145
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Paginator", "src\Paginator.csproj", "{372B4525-5399-4792-BBC7-33BB8897F191}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "UnitTests", "tests\TestCases.csproj", "{48A1CCEB-85F0-4091-8B9F-154D61AF1D5A}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestCases", "tests\TestCases.csproj", "{48A1CCEB-85F0-4091-8B9F-154D61AF1D5A}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{5A9AA53E-5B35-419C-BBCA-C42DD98FBE71}"
 	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
 		.gitattributes = .gitattributes
 		.gitignore = .gitignore
 		_config.yml = _config.yml
diff --git a/Tests/IEnumerableTests.cs b/Tests/IEnumerableTests.cs
index 30a0763..cc7b288 100644
--- a/Tests/IEnumerableTests.cs
+++ b/Tests/IEnumerableTests.cs
@@ -2,8 +2,6 @@
 using System.Collections.Generic;
 using Paginator;
 using System.Linq;
-using System;
-using Common;
 
 namespace Tests
 {
@@ -41,8 +39,8 @@ public void Empty(ICollection<Rate> Rates)
         public void FuncTest(ICollection<string> nums)
         {
             int perpage = 5;
-            
-            var result = nums.Paged(x => x.Matches("0"), 2, perpage);
+
+            var result = nums.Paged(x => x.Equals("0"), 2, perpage, x => x);
             int pages = GetPages(result.TotalItems, perpage);
 
             Assert.AreEqual(2, result.Page);
@@ -53,24 +51,12 @@ public void FuncTest(ICollection<string> nums)
         [Test, TestCaseSource(typeof(Seed), "Pages")]
         public void OrderByProperty(ICollection<Rate> Rates)
         {
-            var result = Rates.ToPaginate(null, 1, 10, "Value", "desc");
+            var result = Rates.ToPaginate(null, 1, 10, x=>x.Value, "desc");
 
             Assert.IsNotNull(result);
             Assert.AreEqual(1, result.Page);
             Assert.AreEqual(Rates.Count, result.TotalItems);
             Assert.Greater(result.Items.First().Value, result.Items.Last().Value);
-            result.Items.ForEach(x =>
-            {
-                Console.WriteLine(x.Value);
-            });
-        }
-
-        [Test, TestCaseSource(typeof(Seed), "Pages")]
-        public void NullRequestTest(ICollection<Rate> list)
-        {
-            var result = list.ToPages(null);
-
-            Assert.AreEqual(1, result.Page);
         }
     }
 }
\ No newline at end of file
diff --git a/Tests/IQueryableTests.cs b/Tests/IQueryableTests.cs
index 5107e7f..3a29793 100644
--- a/Tests/IQueryableTests.cs
+++ b/Tests/IQueryableTests.cs
@@ -38,21 +38,12 @@ public void Empty(ICollection<Rate> Rates)
         public void FuncTest(ICollection<Rate> Rates)
         {
             var result = Rates.AsQueryable()
-                              .Paged(x => x.Value > 9, 2, 2);
+                              .Paged(x => x.Value > 9, 2, 2, x => x.Value);
 
             Assert.NotNull(result);
             Assert.AreEqual(2, result.Page);
             Assert.AreEqual(2, result.ItemsPerPage);
             Assert.AreEqual(Rates.Count(x => x.Value > 9), result.TotalItems);
         }
-
-        [Test, TestCaseSource(typeof(Seed), "Pages")]
-        public void NullRequestTest(ICollection<Rate> list)
-        {
-            var result = list.AsQueryable()
-                             .ToPages(null);
-
-            Assert.AreEqual(1, result.Page);
-        }
     }
 }
\ No newline at end of file
diff --git a/src/PagedResult.cs b/src/PagedResult.cs
index 644000d..9199284 100644
--- a/src/PagedResult.cs
+++ b/src/PagedResult.cs
@@ -22,7 +22,7 @@ public class PagedResult<T>
         /// </summary>
         public PagedResult()
         {
-            Items = new HashSet<T>();
+            Items = new List<T>();
         }
         /// <summary>
         /// Current page in pagination
@@ -45,7 +45,7 @@ public PagedResult()
         /// <summary>
         /// Collection containing items in the current page.
         /// </summary>
-        public ICollection<T> Items { get; set; }
+        public IList<T> Items { get; set; }
 
         /// <summary>
         /// Calculates &amp; returns the hashcode of the current object.
diff --git a/src/Paginator.cs b/src/Paginator.cs
index 5c3a690..9a4cf24 100644
--- a/src/Paginator.cs
+++ b/src/Paginator.cs
@@ -1,5 +1,4 @@
-using Common;
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -18,6 +17,7 @@ public static class Paginator
         /// Number of items to return per page.
         /// </summary>
         private const int _perpage = 10;
+        private const bool _skipCount = false;
 
         #region .Paginate Methods
         /// <summary>
@@ -35,39 +35,43 @@ public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable)
         /// <typeparam name="T">Type of entity in collection.</typeparam>
         /// <param name="page">The page to retrive</param>
         /// <param name="perpage">Number of items per page.</param>
+        /// <param name="skipCount">Whether to avoid running count query &amp; only get required items.</param>
         /// <param name="enumerable">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable, 
-            int page=_page, int perpage=_perpage)
-            where T : class 
-            => enumerable.ProcessPagination(page, perpage);
+        public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable,
+            int page = _page, int perpage = _perpage, bool skipCount = _skipCount)
+            where T : class
+            => enumerable.ProcessPagination(page, perpage, skipCount);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="enumerable">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
+        public static PagedResult<T> Paginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
             where T : class
-            => enumerable.ProcessPagination(predicate);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+        public static PagedResult<T> Paginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
             int page = _page, int perpage = _perpage)
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
@@ -75,10 +79,10 @@ public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable, Func<T,
         /// <param name="orderBy">Property to order by</param>
         /// <param name="order">Ordering type e.g asc or desc</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
-            int page = _page, int perpage = _perpage, string orderBy = null, string order = "asc")
+        public static PagedResult<T> Paginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+            int page = _page, int perpage = _perpage, Func<T, TProperty> orderBy = null, string order = "asc")
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage, orderBy, order);
+            => enumerable.ProcessPagination2(predicate, page, perpage, orderBy, order);
         #endregion
 
         #region .Page Methods
@@ -107,29 +111,32 @@ public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable)
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
+        public static PagedResult<T> Page<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
             where T : class
-            => enumerable.ProcessPagination(predicate);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+        public static PagedResult<T> Page<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
             int page = _page, int perpage = _perpage)
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
@@ -137,10 +144,10 @@ public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable, Func<T, boo
         /// <param name="orderBy">Property to order by</param>
         /// <param name="order">Ordering type e.g asc or desc</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
-            int page = _page, int perpage = _perpage, string orderBy = null, string order = "asc")
+        public static PagedResult<T> Page<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+            int page = _page, int perpage = _perpage, Func<T, TProperty> orderBy = null, string order = "asc")
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage, orderBy, order);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage, orderBy, order);
         #endregion
 
         #region .Paged Methods
@@ -150,6 +157,7 @@ public static PagedResult<T> Page<T>(this IEnumerable<T> enumerable, Func<T, boo
         /// <typeparam name="T">Type of entity in collection.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable)
             where T : class
             => enumerable.ProcessPagination(_page, _perpage);
@@ -161,6 +169,7 @@ public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable)
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable,
             int page = _page, int perpage = _perpage)
             where T : class
@@ -169,29 +178,34 @@ public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable)
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> Paged<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
             where T : class
-            => enumerable.ProcessPagination(predicate);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> Paged<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
             int page = _page, int perpage = _perpage)
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
@@ -199,10 +213,11 @@ public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable, Func<T, bo
         /// <param name="orderBy">Property to order by</param>
         /// <param name="order">Ordering type e.g asc or desc</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
-            int page = _page, int perpage = _perpage, string orderBy = null, string order = "asc")
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> Paged<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+            int page = _page, int perpage = _perpage, Func<T, TProperty> orderBy = null, string order = "asc")
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage, orderBy, order);
+            => enumerable.ProcessPagination2(predicate, page, perpage, orderBy, order);
         #endregion
 
         #region .ToPages Methods
@@ -212,6 +227,7 @@ public static PagedResult<T> Paged<T>(this IEnumerable<T> enumerable, Func<T, bo
         /// <typeparam name="T">Type of entity in collection.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable)
             where T : class
             => enumerable.ProcessPagination(_page, _perpage);
@@ -223,6 +239,7 @@ public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable)
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable,
             int page = _page, int perpage = _perpage)
             where T : class
@@ -231,29 +248,34 @@ public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable)
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPages<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
             where T : class
-            => enumerable.ProcessPagination(predicate);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPages<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
             int page = _page, int perpage = _perpage)
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
@@ -261,10 +283,11 @@ public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable, Func<T,
         /// <param name="orderBy">Property to order by</param>
         /// <param name="order">Ordering type e.g asc or desc</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
-            int page = _page, int perpage = _perpage, string orderBy = null, string order = "asc")
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPages<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+            int page = _page, int perpage = _perpage, Func<T, TProperty> orderBy = null, string order = "asc")
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage, orderBy, order);
+            => enumerable.ProcessPagination2(predicate, page, perpage, orderBy, order);
         #endregion
 
         #region .ToPaginate Methods
@@ -274,6 +297,7 @@ public static PagedResult<T> ToPages<T>(this IEnumerable<T> enumerable, Func<T,
         /// <typeparam name="T">Type of entity in collection.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable)
             where T : class
             => enumerable.ProcessPagination(_page, _perpage);
@@ -285,6 +309,7 @@ public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable)
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable,
             int page = _page, int perpage = _perpage)
             where T : class
@@ -293,29 +318,34 @@ public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable)
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPaginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate)
             where T : class
-            => enumerable.ProcessPagination(predicate);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
         /// <param name="perpage">Number of items per page.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPaginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
             int page = _page, int perpage = _perpage)
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage);
+            => enumerable.ProcessPagination2<T, TProperty>(predicate, page, perpage);
         /// <summary>
         /// Paginate this collection into pages of (x) items each and returns only the first subset.
         /// </summary>
         /// <typeparam name="T">Type of entity in collection.</typeparam>
+        /// <typeparam name="TProperty">Type of the property to order by.</typeparam>
         /// <param name="enumerable">The current collection.</param>
         /// <param name="predicate">A filter to apply to the collection before pagination.</param>
         /// <param name="page">The page to retrieve.</param>
@@ -323,10 +353,11 @@ public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable, Func<
         /// <param name="orderBy">Property to order by</param>
         /// <param name="order">Ordering type e.g asc or desc</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
-        public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
-            int page = _page, int perpage = _perpage, string orderBy = null, string order = "asc")
+        [Obsolete("Use .Paginate instead")]
+        public static PagedResult<T> ToPaginate<T, TProperty>(this IEnumerable<T> enumerable, Func<T, bool> predicate,
+            int page = _page, int perpage = _perpage, Func<T, TProperty> orderBy = null, string order = "asc")
             where T : class
-            => enumerable.ProcessPagination(predicate, page, perpage, orderBy, order);
+            => enumerable.ProcessPagination2(predicate, page, perpage, orderBy, order);
         #endregion
 
         #region IQueryable Methods
@@ -336,6 +367,7 @@ public static PagedResult<T> ToPaginate<T>(this IEnumerable<T> enumerable, Func<
         /// <typeparam name="TEntity">Type of entity in collection.</typeparam>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> Page<TEntity>(this IQueryable<TEntity> entities)
             where TEntity : class
             => entities.ProcessPagination(_page, _perpage);
@@ -347,6 +379,7 @@ public static PagedResult<TEntity> Page<TEntity>(this IQueryable<TEntity> entiti
         /// <param name="perpage">Number of items per page.</param>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> Page<TEntity>(this IQueryable<TEntity> entities,
             int page = _page, int perpage = _perpage)
             where TEntity : class
@@ -357,6 +390,7 @@ public static PagedResult<TEntity> Page<TEntity>(this IQueryable<TEntity> entiti
         /// <typeparam name="TEntity">Type of entity in collection.</typeparam>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> Paged<TEntity>(this IQueryable<TEntity> entities)
             where TEntity : class
             => entities.ProcessPagination(_page, _perpage);
@@ -368,6 +402,7 @@ public static PagedResult<TEntity> Paged<TEntity>(this IQueryable<TEntity> entit
         /// <param name="perpage">Number of items per page.</param>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> Paged<TEntity>(this IQueryable<TEntity> entities,
             int page = _page, int perpage = _perpage)
             where TEntity : class
@@ -378,6 +413,7 @@ public static PagedResult<TEntity> Paged<TEntity>(this IQueryable<TEntity> entit
         /// <typeparam name="TEntity">Type of entity in collection.</typeparam>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> ToPages<TEntity>(this IQueryable<TEntity> entities)
             where TEntity : class
             => entities.ProcessPagination(_page, _perpage);
@@ -389,6 +425,7 @@ public static PagedResult<TEntity> ToPages<TEntity>(this IQueryable<TEntity> ent
         /// <param name="perpage">Number of items per page.</param>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
+        [Obsolete("Use .Paginate instead")]
         public static PagedResult<TEntity> ToPages<TEntity>(this IQueryable<TEntity> entities,
             int page = _page, int perpage = _perpage)
             where TEntity : class
@@ -408,18 +445,29 @@ public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> en
         /// <typeparam name="TEntity">Type of entity in collection.</typeparam>
         /// <param name="page">The page to retrive</param>
         /// <param name="perpage">Number of items per page.</param>
+        /// <param name="skipCount">Whether to avoid running count query &amp; only get required items.</param>
         /// <param name="entities">The current collection.</param>
         /// <returns><see cref="PagedResult{T}"/>.</returns>
         public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> entities,
-            int page = _page, int perpage = _perpage)
+            int page = _page, int perpage = _perpage, bool skipCount = _skipCount)
             where TEntity : class
-            => entities.ProcessPagination(page, perpage);
+            => entities.ProcessPagination(page, perpage, skipCount);
         #endregion
 
-        internal static PagedResult<TEntity> ProcessPagination<TEntity>(this IQueryable<TEntity> entities,
-                    int page = _page, int perpage = _perpage)
+        internal static PagedResult<TEntity> ProcessPagination<TEntity>(this IQueryable<TEntity> query,
+                    int page = _page, int perpage = _perpage, bool skipCount = _skipCount)
         {
-            int total = entities.CountEntities();
+            int total = 0;
+            var list = new List<TEntity>();
+
+            if (!skipCount)
+                total = query.CountEntities();
+
+            if (skipCount || (!skipCount && total > 0))
+                list = query.Skip((page - 1) * perpage).Take(perpage).ToList();
+
+            if (skipCount)
+                total = list.Count;
 
             return new PagedResult<TEntity>()
             {
@@ -427,13 +475,23 @@ public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> en
                 ItemsPerPage = perpage,
                 TotalItems = total,
                 TotalPages = CalculateTotalPages(total, perpage),
-                Items = entities.Skip((page - 1) * perpage).Take(perpage).ToList()
+                Items = list
             };
         }
         internal static PagedResult<T> ProcessPagination<T>(this IEnumerable<T> enumerable,
-                    int page = _page, int perpage = _perpage)
+                    int page = _page, int perpage = _perpage, bool skipCount = _skipCount)
         {
-            int total = enumerable.CountItems();
+            int total = 0;
+            var list = new List<T>();
+
+            if (!skipCount)
+                total = enumerable.CountItems();
+
+            if (skipCount || (!skipCount && total > 0))
+                list = enumerable.Skip((page - 1) * perpage).Take(perpage).ToList();
+
+            if (skipCount)
+                total = list.Count;
 
             return new PagedResult<T>()
             {
@@ -441,25 +499,24 @@ public static PagedResult<TEntity> Paginate<TEntity>(this IQueryable<TEntity> en
                 ItemsPerPage = perpage,
                 TotalItems = total,
                 TotalPages = CalculateTotalPages(total, perpage),
-                Items = enumerable.Skip((page - 1) * perpage).Take(perpage).ToList()
+                Items = list
             };
         }
-        internal static PagedResult<T> ProcessPagination<T>(this IEnumerable<T> enumerable,
-            Func<T, bool> predicate=null, int page = _page, int perpage = _perpage, string orderBy = null,
+        internal static PagedResult<T> ProcessPagination2<T, TProperty>(this IEnumerable<T> enumerable,
+            Func<T, bool> predicate=null, int page = _page, int perpage = _perpage, Func<T,TProperty> orderBy = null,
             string order = "asc") where T : class
         {
             int total = 0;
             IEnumerable<T> query;
 
             query = predicate != null ? enumerable.Where(predicate) : enumerable;
-            if (orderBy.IsValid())
-            {
-                query = order == "asc" ? query.OrderBy(x => x.GetPropertyValue<T, object>(orderBy)) :
-                       order == "desc" ? query.OrderByDescending(x => x.GetPropertyValue<T, object>(orderBy)) : query;
-            }
-
             total = query.CountItems();
 
+            if (orderBy != null)
+            {
+                query = order.Equals("asc", StringComparison.OrdinalIgnoreCase) ? query.OrderBy(orderBy) :
+                       order.Equals("desc", StringComparison.OrdinalIgnoreCase) ? query.OrderByDescending(orderBy) : query;
+            }
 
             PagedResult<T> result = new PagedResult<T>()
             {
diff --git a/src/Paginator.csproj b/src/Paginator.csproj
index 1769dce..35ab676 100644
--- a/src/Paginator.csproj
+++ b/src/Paginator.csproj
@@ -5,7 +5,8 @@
     <TargetFrameworks>
       netstandard2.0;
       netcoreapp3.0;netcoreapp2.0;netcoreapp2.1;
-      net47
+      <!--net47,-->
+	  net48
     </TargetFrameworks>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
@@ -18,19 +19,18 @@
     <RepositoryUrl>https://github.com/tmacharia/linq-paginator</RepositoryUrl>
     <PackageTags>linq, pagination, list paginator, paging, list, array, collection</PackageTags>
     <Description>For queries that return a lot of data, a need emerges to consume the results in chunks rather than the entire set. Consuming all results at once can be costly in terms of network traffic thus slowing down your application.
-      Linq Paginator allows you to run your queries and return your data in form of pages. A page contains a set number of items to return per page e.g 20. If for example you have 100 records, it will return the following object:
+    Linq Paginator allows you to run your queries and return your data in form of pages. A page contains a set number of items to return per page e.g 20. If for example you have 100 records, it will return the following object:
       - Page: 1,
       - TotalPages: 5,
       - ItemsPerPage: 20,
       - TotalItems: 100,
-      - List (collection of the first 20 records)
+      - Items (collection of the first 20 records)
 </Description>
     <PackageId>LinqPaginator</PackageId>
-    <Version>1.2.6</Version>
+    <Version>1.2.7</Version>
     <NeutralLanguage>en</NeutralLanguage>
     <PackageReleaseNotes>
-      Fixes bug/issue with pagination result:
-      -&gt; TotalPages is always zero
+      Fixes bug/issue casting.
     </PackageReleaseNotes>
     <PackageLicenseUrl></PackageLicenseUrl>
     <RepositoryType>git</RepositoryType>
@@ -42,12 +42,9 @@
     <DocumentationFile></DocumentationFile>
   </PropertyGroup>-->
 
-  <ItemGroup>
-    <PackageReference Include="Shared.Common" Version="1.3.5" />
-  </ItemGroup>
-
    <!--Conditionally obtain references for .NET Core 1.1 target--> 
   <ItemGroup>
+    <None Include="..\.editorconfig" Link=".editorconfig" />
     <None Include="..\LICENSE">
       <Pack>True</Pack>
       <PackagePath></PackagePath>
diff --git a/tests/TestCases.csproj b/tests/TestCases.csproj
index bf4d635..1ffc63f 100644
--- a/tests/TestCases.csproj
+++ b/tests/TestCases.csproj
@@ -5,10 +5,10 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
-    <PackageReference Include="NUnit" Version="3.9.0" />
-    <PackageReference Include="NUnit.Console" Version="3.10.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.9.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.1" />
+    <PackageReference Include="NUnit" Version="3.13.1" />
+    <PackageReference Include="NUnit.Console" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>
 
   <ItemGroup>