Extend the OrderBy capabilities with comma separated support for then by

Author: zdrawku

NorthwindCRUD/Controllers/ProductsController.cs

@@ -50,11 +50,11 @@ public ActionResult<ProductDto[]> GetAll()
         /// <summary>
         /// Fetches all products or a page of products based on the provided parameters.
         /// </summary>
-        /// <param name="skip">Previously called pageNumber. The number of the page to fetch. If this parameter is not provided, all products are fetched.</param>
-        /// <param name="top">Previously called pageSize. The size of the page to fetch. If this parameter is not provided, all products are fetched.</param>
-        /// <param name="orderBy">The fields to order by, in the format "field1 asc, field2 desc". If not provided, defaults to no specific order.</param>
+        /// <param name="skip">The number of records to skip before starting to fetch the products. If this parameter is not provided, fetching starts from the beginning.</param>
+        /// <param name="top">The maximum number of products to fetch. If this parameter is not provided, all products are fetched.</param>
+        /// <param name="orderBy">A comma-separated list of fields to order the products by, along with the sort direction (e.g., "field1 asc, field2 desc").</param>
         /// <returns>A PagedResultDto object containing the fetched T and the total record count.</returns>
-        [HttpGet("GetAllPagedProducts")]
+        [HttpGet("GetPagedProducts")]
         public ActionResult<PagedResultDto<ProductDto>> GetAllProducts(int? skip, int? top, string? orderBy)
         {
             try

NorthwindCRUD/Services/PagingService.cs

@@ -1,4 +1,5 @@
 using System.Globalization;
+using System.Linq.Expressions;
 using System.Reflection;
 using AutoMapper;
 using Microsoft.AspNetCore.Mvc.RazorPages;
@@ -32,18 +33,7 @@ public PagedResultDto<TDto> GetPagedData<TEntity, TDto>(IEnumerable<TEntity> dat
             // Apply ordering if specified
             if (!string.IsNullOrEmpty(orderBy))
             {
-                var orderByParts = orderBy.Split(' ');
-                var field = orderByParts[0];
-                var order = orderByParts.Length > 1 ? orderByParts[1] : "ASC";
-
-                var propertyInfo = typeof(TEntity).GetProperty(field, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
-
-                if (propertyInfo != null)
-                {
-                    dataArray = order.ToUpper(CultureInfo.InvariantCulture) == "DESC"
-                        ? dataArray.OrderByDescending(e => propertyInfo.GetValue(e, null)).ToArray()
-                        : dataArray.OrderBy(e => propertyInfo.GetValue(e, null)).ToArray();
-                }
+                dataArray = ApplyOrdering(dataArray.AsQueryable(), orderBy).ToArray();
             }
 
             // Apply pagination
@@ -67,5 +57,46 @@ public PagedResultDto<TDto> GetPagedData<TEntity, TDto>(IEnumerable<TEntity> dat
                 TotalPages = totalPages,
             };
         }
+
+        private IQueryable<TEntity> ApplyOrdering<TEntity>(IQueryable<TEntity> source, string orderBy)
+        {
+            var orderParams = orderBy.Split(',');
+
+            IOrderedQueryable<TEntity>? orderedQuery = null;
+
+            foreach (var param in orderParams)
+            {
+                var trimmedParam = param.Trim();
+                var orderByParts = trimmedParam.Split(' ');
+                var field = orderByParts[0];
+                var order = orderByParts.Length > 1 ? orderByParts[1] : "asc";
+
+                var propertyInfo = typeof(TEntity).GetProperty(field, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
+
+                if (propertyInfo != null)
+                {
+                    var parameter = Expression.Parameter(typeof(TEntity), "x");
+                    var property = Expression.Property(parameter, propertyInfo);
+                    var lambda = Expression.Lambda(property, parameter);
+
+                    var methodName = order.ToUpper(CultureInfo.InvariantCulture) == "DESC"
+                        ? (orderedQuery == null ? "OrderByDescending" : "ThenByDescending")
+                        : (orderedQuery == null ? "OrderBy" : "ThenBy");
+
+                    var resultExpression = Expression.Call(
+                        typeof(Queryable),
+                        methodName,
+                        new Type[] { source.ElementType, property.Type },
+                        (orderedQuery ?? source).Expression,
+                        Expression.Quote(lambda));
+
+                    orderedQuery = (IOrderedQueryable<TEntity>)(orderedQuery == null
+                        ? source.Provider.CreateQuery<TEntity>(resultExpression)
+                        : orderedQuery.Provider.CreateQuery<TEntity>(resultExpression));
+                }
+            }
+
+            return orderedQuery ?? source;
+        }
     }
 }