Aggregate (fixed issue #102)

Author: StefH

ChangeLog.txt

@@ -1,3 +1,3 @@
 https://github.com/GitTools/GitReleaseNotes
 
-GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.7.6
+GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.7.7

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

@@ -48,6 +48,60 @@ private static Expression OptimizeExpression(Expression expression)
             return expression;
         }
 
+        #region Aggregate
+        /// <summary>
+        /// Dynamically runs an aggregate function on the IQueryable.
+        /// </summary>
+        /// <param name="source">The IQueryable data source.</param>
+        /// <param name="function">The name of the function to run. Can be Sum, Average, Min or Max.</param>
+        /// <param name="member">The name of the property to aggregate over.</param>
+        /// <returns>The value of the aggregate function run over the specified property.</returns>
+        public static object Aggregate([NotNull] this IQueryable source, [NotNull] string function, [NotNull] string member)
+        {
+            Check.NotNull(source, nameof(source));
+            Check.NotEmpty(function, nameof(function));
+            Check.NotEmpty(member, nameof(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 && x.IsGenericMethod);
+
+            // Method
+            MethodInfo aggregateMethod = methods.SingleOrDefault(m =>
+            {
+                ParameterInfo lastParameter = m.GetParameters().LastOrDefault();
+
+                return lastParameter != null ? ExpressionParser.GetUnderlyingType(lastParameter.ParameterType) == property.PropertyType : false;
+            });
+
+            // 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 = methods.SingleOrDefault(m => m.Name == function && m.GetGenericArguments().Length == 2);
+
+                return source.Provider.Execute(
+                    Expression.Call(
+                        null,
+                        aggregateMethod.MakeGenericMethod(new[] { source.ElementType, property.PropertyType }),
+                        new[] { source.Expression, Expression.Quote(selector) }));
+            }
+        }
+        #endregion Aggregate
+
         #region Any
         private static readonly MethodInfo _any = GetMethod(nameof(Queryable.Any));
 

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

@@ -6,6 +6,7 @@
 using System.Globalization;
 using System.Linq.Dynamic.Core.Exceptions;
 using System.Linq.Dynamic.Core.Tokenizer;
+using System.Linq.Dynamic.Core.Validation;
 
 namespace System.Linq.Dynamic.Core
 {
@@ -1745,22 +1746,42 @@ static bool IsPredefinedType(Type type)
 
         public static bool IsNullableType(Type type)
         {
+            Check.NotNull(type, nameof(type));
+
             return type.GetTypeInfo().IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
         }
 
         public static Type ToNullableType(Type type)
         {
+            Check.NotNull(type, nameof(type));
+
             if (!type.GetTypeInfo().IsValueType || IsNullableType(type))
                 throw ParseError(-1, Res.TypeHasNoNullableForm, GetTypeName(type));
 
             return typeof(Nullable<>).MakeGenericType(type);
         }
 
-        static Type GetNonNullableType(Type type)
+        public static Type GetNonNullableType(Type type)
         {
+            Check.NotNull(type, nameof(type));
+
             return IsNullableType(type) ? type.GetTypeInfo().GetGenericTypeArguments()[0] : type;
         }
 
+        public static Type GetUnderlyingType(Type type)
+        {
+            Check.NotNull(type, nameof(type));
+
+            var genericTypeArguments = type.GetGenericArguments();
+            if (genericTypeArguments.Any())
+            {
+                var outerType = GetUnderlyingType(genericTypeArguments.LastOrDefault());
+                return Nullable.GetUnderlyingType(type) == outerType ? type : outerType;
+            }
+
+            return type;
+        }
+
         static string GetTypeName(Type type)
         {
             Type baseType = GetNonNullableType(type);

src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.csproj

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>This is a .NETStandard/ .NET Core port of the the Microsoft assembly for the .Net 4.0 Dynamic language functionality.</Description>
     <AssemblyTitle>System.Linq.Dynamic.Core</AssemblyTitle>
-    <VersionPrefix>1.0.7.6</VersionPrefix>
+    <VersionPrefix>1.0.7.7</VersionPrefix>
     <Authors>Microsoft;Scott Guthrie;King Wilder;Nathan Arnott;Stef Heyenrath</Authors>
     <TargetFrameworks>net35;net40;net45;net46;netstandard1.3;uap10.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>

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

@@ -0,0 +1,76 @@
+using Xunit;
+
+namespace System.Linq.Dynamic.Core.Tests
+{
+    public partial class QueryableTests
+    {
+        [Fact]
+        public void Aggregate_Average()
+        {
+            // Arrange
+            var queryable = new[]
+            {
+                new AggregateTest { Double = 50, Float = 1.0f, Int = 42, NullableDouble = 400, NullableFloat = 100f, NullableInt = 60 },
+                new AggregateTest { Double = 0, Float = 0.0f, Int = 0, NullableDouble = 0, NullableFloat = 0, NullableInt = 0 }
+            }.AsQueryable();
+
+            // Act
+            var resultNullableFloat = queryable.Aggregate("Average", "NullableFloat");
+            var resultFloat = queryable.Aggregate("Average", "Float");
+            var resultDouble = queryable.Aggregate("Average", "Double");
+            var resultNullableDouble = queryable.Aggregate("Average", "NullableDouble");
+            var resultInt = queryable.Aggregate("Average", "Int");
+            var resultNullableInt = queryable.Aggregate("Average", "NullableInt");
+
+            // Assert
+            Assert.Equal(50f, resultNullableFloat);
+            Assert.Equal(200.0, resultNullableDouble);
+            Assert.Equal(25.0, resultDouble);
+            Assert.Equal(0.5f, resultFloat);
+            Assert.Equal(21.0, resultInt);
+            Assert.Equal(30.0, resultNullableInt);
+        }
+
+        [Fact]
+        public void Aggregate_Min()
+        {
+            // Arrange
+            var queryable = new[]
+            {
+                new AggregateTest { Double = 50, Float = 1.0f, Int = 42, NullableDouble = 400, NullableFloat = 100f, NullableInt = 60 },
+                new AggregateTest { Double = 51, Float = 2.0f, Int = 90, NullableDouble = 800, NullableFloat = 101f, NullableInt = 61 }
+            }.AsQueryable();
+
+            // Act
+            var resultDouble = queryable.Aggregate("Min", "Double");
+            var resultFloat = queryable.Aggregate("Min", "Float");
+            var resultInt = queryable.Aggregate("Min", "Int");
+            var resultNullableDouble = queryable.Aggregate("Min", "NullableDouble");
+            var resultNullableFloat = queryable.Aggregate("Min", "NullableFloat");
+            var resultNullableInt = queryable.Aggregate("Min", "NullableInt");
+
+            // Assert
+            Assert.Equal(50.0, resultDouble);
+            Assert.Equal(1.0f, resultFloat);
+            Assert.Equal(42, resultInt);
+            Assert.Equal(400.0, resultNullableDouble);
+            Assert.Equal(100f, resultNullableFloat);
+            Assert.Equal(60, resultNullableInt);
+        }
+
+        public class AggregateTest
+        {
+            public double Double { get; set; }
+
+            public double? NullableDouble { get; set; }
+
+            public float Float { get; set; }
+
+            public float? NullableFloat { get; set; }
+
+            public int Int { get; set; }
+
+            public int? NullableInt { get; set; }
+        }
+    }
+}