Add support for all numeric data types to summary aggregate functions

Collapse aggregates into one basic function

Author: programcsharp

Griddly.Mvc/DynamicLinq.cs

@@ -32,18 +32,41 @@ public static IQueryable Where(this IQueryable source, string predicate, params
                     source.Expression, Expression.Quote(lambda)));
         }
 
-        public static IQueryable Select(this IQueryable source, string selector, params object[] values)
+        //public static IQueryable Select(this IQueryable source, string selector, params object[] values)
+        //{
+        //    if (source == null) throw new ArgumentNullException("source");
+        //    if (selector == null) throw new ArgumentNullException("selector");
+        //    LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values);
+        //    return source.Provider.CreateQuery(
+        //        Expression.Call(
+        //            typeof(Queryable), "Select",
+        //            new Type[] { source.ElementType, lambda.Body.Type },
+        //            source.Expression, Expression.Quote(lambda)));
+        //}
+
+        // https://code.google.com/p/dynamic-linq/
+        public static IQueryable Select(this IQueryable source, Type type, string selector, params object[] values)
         {
             if (source == null) throw new ArgumentNullException("source");
             if (selector == null) throw new ArgumentNullException("selector");
-            LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, null, selector, values);
+            LambdaExpression lambda = DynamicExpression.ParseLambda(source.ElementType, type, selector, values);
             return source.Provider.CreateQuery(
                 Expression.Call(
                     typeof(Queryable), "Select",
                     new Type[] { source.ElementType, lambda.Body.Type },
                     source.Expression, Expression.Quote(lambda)));
         }
 
+        public static IQueryable Select(this IQueryable source, string selector, params object[] values)
+        {
+            return Select(source, null, selector, values);
+        }
+
+        public static IQueryable<T> Select<T>(this IQueryable source, string selector, params object[] values)
+        {
+            return Select(source, typeof(T), selector, values) as IQueryable<T>;
+        }
+        
         public static IQueryable<T> OrderBy<T>(this IQueryable<T> source, string ordering, params object[] values)
         {
             return (IQueryable<T>)OrderBy((IQueryable)source, ordering, values);
@@ -123,6 +146,52 @@ public static int Count(this IQueryable source)
                     typeof(Queryable), "Count",
                     new Type[] { source.ElementType }, source.Expression));
         }
+
+        // http://stackoverflow.com/questions/17490080/how-to-do-a-sum-using-dynamic-linq
+        public static object Aggregate(this IQueryable source, string function, string member)
+        {
+            if (source == null) throw new ArgumentNullException("source");
+            if (member == null) throw new ArgumentNullException("member");
+
+            // Properties
+            PropertyInfo property = source.ElementType.GetProperty(member);
+            ParameterExpression parameter = Expression.Parameter(source.ElementType, "s");
+            Expression selector = Expression.Lambda(Expression.MakeMemberAccess(parameter, property), parameter);
+            // We've tried to find an expression of the type Expression<Func<TSource, TAcc>>,
+            // which is expressed as ( (TSource s) => s.Price );
+
+            var methods = typeof(Queryable).GetMethods().Where(x => x.Name == function);
+
+            // Method
+            MethodInfo aggregateMethod = typeof(Queryable).GetMethods().SingleOrDefault(
+                m => m.Name == function
+                    && m.ReturnType == property.PropertyType // should match the type of the property
+                    && m.IsGenericMethod);
+
+            // Sum, Average
+            if (aggregateMethod != null)
+            {
+                return source.Provider.Execute(
+                    Expression.Call(
+                        null,
+                        aggregateMethod.MakeGenericMethod(new[] { source.ElementType }),
+                        new[] { source.Expression, Expression.Quote(selector) }));
+            }
+            // Min, Max
+            else
+            {
+                aggregateMethod = typeof(Queryable).GetMethods().SingleOrDefault(
+                m => m.Name == function
+                    && m.GetGenericArguments().Length == 2
+                    && m.IsGenericMethod);
+
+                return source.Provider.Execute(
+                    Expression.Call(
+                        null,
+                        aggregateMethod.MakeGenericMethod(new[] { source.ElementType, property.PropertyType }),
+                        new[] { source.Expression, Expression.Quote(selector) }));
+            }
+        }
     }
 
     public abstract class DynamicClass

Griddly.Mvc/GriddlyResult.cs

@@ -1,14 +1,13 @@
-using System;
+using Griddly.Mvc.Linq.Dynamic;
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
-using System.Text;
 using System.Web.Helpers;
 using System.Web.Mvc;
-using Griddly.Mvc.Linq.Dynamic;
 
 namespace Griddly.Mvc
 {
@@ -224,21 +223,13 @@ public virtual void PopulateSummaryValues(GriddlySettings<T> settings)
                 switch (c.SummaryFunction.Value)
                 {
                     case SummaryAggregateFunction.Sum:
-                        c.SummaryValue = _result.Select(c.ExpressionString).Cast<decimal?>().Sum();
-
-                        break;
                     case SummaryAggregateFunction.Average:
-                        c.SummaryValue = _result.Select(c.ExpressionString).Cast<decimal?>().Average();
-
-                        break;
                     case SummaryAggregateFunction.Min:
-                        c.SummaryValue = _result.Select(c.ExpressionString).Cast<decimal?>().Min();
-
-                        break;
                     case SummaryAggregateFunction.Max:
-                        c.SummaryValue = _result.Select(c.ExpressionString).Cast<decimal?>().Max();
+                        c.SummaryValue = _result.Aggregate(c.SummaryFunction.Value.ToString(), c.ExpressionString);
 
                         break;
+
                     default:
                         throw new InvalidOperationException(string.Format("Unknown summary function {0} for column {1}.", c.SummaryFunction, c.ExpressionString));
                 }