Added ThenBy (#62)

Author: StefH

src/System.Linq.Dynamic.Core/DynamicQueryableExtensions.cs

@@ -574,7 +574,7 @@ public static IOrderedQueryable OrderBy([NotNull] this IQueryable source, [NotNu
 
             ParameterExpression[] parameters = { Expression.Parameter(source.ElementType, "") };
             ExpressionParser parser = new ExpressionParser(parameters, ordering, args);
-            IEnumerable<DynamicOrdering> dynamicOrderings = parser.ParseOrdering();
+            IList<DynamicOrdering> dynamicOrderings = parser.ParseOrdering();
 
             Expression queryExpr = source.Expression;
 
@@ -1142,7 +1142,70 @@ public static IQueryable TakeWhile([NotNull] this IQueryable source, [NotNull] s
 
             return CreateQuery(_takeWhilePredicate, source, lambda);
         }
-#endregion TakeWhile
+        #endregion TakeWhile
+
+#region ThenBy
+        /// <summary>
+        /// Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
+        /// </summary>
+        /// <typeparam name="TSource">The type of the elements of source.</typeparam>
+        /// <param name="source">A sequence of values to order.</param>
+        /// <param name="ordering">An expression string to indicate values to order by.</param>
+        /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters. Similar to the way String.Format formats strings.</param>
+        /// <returns>A <see cref="IOrderedQueryable{T}"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
+        /// <example>
+        /// <code>
+        /// <![CDATA[
+        /// var result = queryable.OrderBy<User>("LastName");
+        /// var resultSingle = result.ThenBy<User>("NumberProperty");
+        /// var resultSingleDescending = result.ThenBy<User>("NumberProperty DESC");
+        /// var resultMultiple = result.ThenBy<User>("NumberProperty, StringProperty");
+        /// ]]>
+        /// </code>
+        /// </example>
+        public static IOrderedQueryable<TSource> ThenBy<TSource>([NotNull] this IOrderedQueryable<TSource> source, [NotNull] string ordering, params object[] args)
+        {
+            return (IOrderedQueryable<TSource>)ThenBy((IOrderedQueryable)source, ordering, args);
+        }
+
+        /// <summary>
+        /// Performs a subsequent ordering of the elements in a sequence in ascending order according to a key.
+        /// </summary>
+        /// <param name="source">A sequence of values to order.</param>
+        /// <param name="ordering">An expression string to indicate values to order by.</param>
+        /// <param name="args">An object array that contains zero or more objects to insert into the predicate as parameters.  Similar to the way String.Format formats strings.</param>
+        /// <returns>A <see cref="IQueryable"/> whose elements are sorted according to the specified <paramref name="ordering"/>.</returns>
+        /// <example>
+        /// <code>
+        /// var result = queryable.OrderBy("LastName");
+        /// var resultSingle = result.OrderBy("NumberProperty");
+        /// var resultSingleDescending = result.OrderBy("NumberProperty DESC");
+        /// var resultMultiple = result.OrderBy("NumberProperty, StringProperty DESC");
+        /// </code>
+        /// </example>
+        public static IOrderedQueryable ThenBy([NotNull] this IOrderedQueryable source, [NotNull] string ordering, params object[] args)
+        {
+            Check.NotNull(source, nameof(source));
+            Check.NotEmpty(ordering, nameof(ordering));
+
+            ParameterExpression[] parameters = { Expression.Parameter(source.ElementType, "") };
+            ExpressionParser parser = new ExpressionParser(parameters, ordering, args);
+            IList<DynamicOrdering> dynamicOrderings = parser.ParseOrdering(forceThenBy: true);
+
+            Expression queryExpr = source.Expression;
+
+            foreach (DynamicOrdering dynamicOrdering in dynamicOrderings)
+            {
+                queryExpr = Expression.Call(
+                    typeof(Queryable), dynamicOrdering.MethodName,
+                    new[] { source.ElementType, dynamicOrdering.Selector.Type },
+                    queryExpr, Expression.Quote(Expression.Lambda(dynamicOrdering.Selector, parameters)));
+            }
+
+            var optimized = OptimizeExpression(queryExpr);
+            return (IOrderedQueryable)source.Provider.CreateQuery(optimized);
+        }
+#endregion OrderBy
 
 #region Where
         /// <summary>

src/System.Linq.Dynamic.Core/ExpressionParser.cs

@@ -141,6 +141,8 @@ interface IEnumerableSignatures
             void SelectMany(object selector);
             void OrderBy(object selector);
             void OrderByDescending(object selector);
+            void ThenBy(object selector);
+            void ThenByDescending(object selector);
             void Contains(object selector);
             void Skip(int count);
             void SkipWhile(bool predicate);
@@ -330,7 +332,7 @@ public Expression Parse(Type resultType, bool createParameterCtor)
         }
 
 #pragma warning disable 0219
-        public IEnumerable<DynamicOrdering> ParseOrdering()
+        public IList<DynamicOrdering> ParseOrdering(bool forceThenBy = false)
         {
             var orderings = new List<DynamicOrdering>();
             while (true)
@@ -348,10 +350,10 @@ public IEnumerable<DynamicOrdering> ParseOrdering()
                 }
 
                 string methodName;
-                if (orderings.Count == 0)
-                    methodName = ascending ? methodOrderBy : methodOrderByDescending;
-                else
+                if (forceThenBy || orderings.Count > 0)
                     methodName = ascending ? methodThenBy : methodThenByDescending;
+                else
+                    methodName = ascending ? methodOrderBy : methodOrderByDescending;
 
                 orderings.Add(new DynamicOrdering { Selector = expr, Ascending = ascending, MethodName = methodName });
 
@@ -1386,7 +1388,7 @@ Expression ParseAggregate(Expression instance, Type elementType, string methodNa
                 throw ParseError(errorPos, Res.NoApplicableAggregate, methodName);
 
             Type[] typeArgs;
-            if (new[] { "Min", "Max", "Select", "OrderBy", "OrderByDescending" }.Contains(signature.Name))
+            if (new[] { "Min", "Max", "Select", "OrderBy", "OrderByDescending", "ThenBy", "ThenByDescending" }.Contains(signature.Name))
             {
                 typeArgs = new[] { elementType, args[0].Type };
             }

src/System.Linq.Dynamic.Core/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.0.6.10",
+    "version": "1.0.6.11",
     "title": "System.Linq.Dynamic.Core",
     "description": "This is a .NET Core port of the the Microsoft assembly for the .Net 4.0 Dynamic language functionality.",
     "authors": [ "Microsoft", "Scott Guthrie", "King Wilder", "Nathan Arnott", "Stef Heyenrath" ],
@@ -14,7 +14,7 @@
         },
         "projectUrl": "https://github.com/StefH/System.Linq.Dynamic.Core",
         "licenseUrl": "https://github.com/StefH/System.Linq.Dynamic.Core/blob/master/licence.txt",
-        "releaseNotes": "Add [] to DynamicClass"
+        "releaseNotes": "Added support for ThenBy."
     },
 
     "buildOptions": {
@@ -100,19 +100,19 @@
                 "dotnet5.4"
             ],
             "dependencies": {
-                "System.Collections.Concurrent": "4.0.12",
-                "System.ComponentModel.TypeConverter": "4.1.0",
-                "System.Diagnostics.Debug": "4.0.11",
-                "System.Diagnostics.TraceSource": "4.0.0",
-                "System.Dynamic.Runtime": "4.0.11",
-                "System.Globalization": "4.0.11",
-                "System.Linq.Expressions": "4.1.0",
-                "System.Linq.Queryable": "4.0.1",
-                "System.ObjectModel": "4.0.12",
-                "System.Reflection.Emit": "4.0.1",
-                "System.Reflection.TypeExtensions": "4.1.0",
-                "System.Runtime.Extensions": "4.1.0",
-                "System.Threading": "4.0.11"
+                "System.Collections.Concurrent": "4.3.0",
+                "System.ComponentModel.TypeConverter": "4.3.0",
+                "System.Diagnostics.Debug": "4.3.0",
+                "System.Diagnostics.TraceSource": "4.3.0",
+                "System.Dynamic.Runtime": "4.3.0",
+                "System.Globalization": "4.3.0",
+                "System.Linq.Expressions": "4.3.0",
+                "System.Linq.Queryable": "4.3.0",
+                "System.ObjectModel": "4.3.0",
+                "System.Reflection.Emit": "4.3.0",
+                "System.Reflection.TypeExtensions": "4.3.0",
+                "System.Runtime.Extensions": "4.3.0",
+                "System.Threading": "4.3.0"
             }
         },
         "sl5": {

test/System.Linq.Dynamic.Core.Tests/QueryableTests.OrderBy.cs

@@ -22,7 +22,6 @@ public void OrderBy_Dynamic()
             Assert.Equal(testList.OrderBy(x => x.Id).ToArray(), orderById.ToArray());
             Assert.Equal(testList.OrderBy(x => x.Profile.Age).ToArray(), orderByAge.ToArray());
             Assert.Equal(testList.OrderBy(x => x.Profile.Age).ThenBy(x => x.Id).ToArray(), orderByComplex1.ToArray());
-            
         }
 
         [Fact]

test/System.Linq.Dynamic.Core.Tests/QueryableTests.ThenBy.cs

@@ -0,0 +1,59 @@
+using System.Linq.Dynamic.Core.Exceptions;
+using System.Linq.Dynamic.Core.Tests.Helpers.Models;
+using Xunit;
+
+namespace System.Linq.Dynamic.Core.Tests
+{
+    public partial class QueryableTests
+    {
+        [Fact]
+        public void ThenBy_Dynamic()
+        {
+            //Arrange
+            var testList = User.GenerateSampleModels(100);
+            var qry = testList.AsQueryable();
+
+            //Act
+			var ordered = qry.OrderBy("Id");
+            var thenByUserName = ordered.ThenBy("UserName");
+            var thenByComplex1 = ordered.ThenBy("Profile.Age, Income");
+
+            //Assert
+            Assert.Equal(testList.OrderBy(x => x.Id).ThenBy(x => x.UserName).ToArray(), thenByUserName.ToArray());
+            Assert.Equal(testList.OrderBy(x => x.Id).ThenBy(x => x.Profile.Age).ThenBy(x => x.Income).ToArray(), thenByComplex1.ToArray());
+        }
+
+        [Fact]
+        public void ThenBy_Dynamic_AsStringExpression()
+        {
+            //Arrange
+            var testList = User.GenerateSampleModels(100);
+            var qry = testList.AsQueryable();
+
+            //Act
+            var expected = qry.SelectMany(x => x.Roles.OrderBy(y => y.Name).ThenBy(y => y.Id)).Select(x => x.Name);
+            var orderById = qry.SelectMany("Roles.OrderBy(Name).ThenBy(Id)").Select("Name");
+
+            //Assert
+            Assert.Equal(expected.ToArray(), orderById.Cast<string>().ToArray());
+        }
+
+        [Fact]
+        public void ThenBy_Dynamic_Exceptions()
+        {
+            //Arrange
+            var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
+            var qry = testList.AsQueryable();
+
+            //Act
+            var ordered = qry.OrderBy("Id");
+            Assert.Throws<ParseException>(() => ordered.ThenBy("Bad=3"));
+            Assert.Throws<ParseException>(() => ordered.Where("Id=123"));
+
+            Assert.Throws<ArgumentNullException>(() => DynamicQueryableExtensions.ThenBy(null, "Id"));
+            Assert.Throws<ArgumentNullException>(() => ordered.ThenBy(null));
+            Assert.Throws<ArgumentException>(() => ordered.ThenBy(""));
+            Assert.Throws<ArgumentException>(() => ordered.ThenBy(" "));
+        }
+    }
+}