supporting equality comparer :)

PoweredSoft.DynamicLinq/Constants.cs

@@ -44,6 +44,7 @@ namespace PoweredSoft.DynamicLinq
     internal static class Constants
     {
         internal static readonly MethodInfo GroupByMethod = typeof(Queryable).GetMethods().First(t => t.Name == "GroupBy");
+        internal static readonly MethodInfo GroupByMethodWithEqualityComparer = typeof(Queryable).GetMethods().First(t => t.Name == "GroupBy" && t.GetParameters().Any(t2 => t2.Name == "comparer"));
         internal static readonly MethodInfo StringEqualWithComparisation = typeof(string).GetMethod("Equals", new Type[] { typeof(string), typeof(StringComparison) });
         internal static readonly MethodInfo ContainsMethod = typeof(string).GetMethod("Contains");
         internal static readonly MethodInfo StartsWithMethod = typeof(string).GetMethod("StartsWith", new Type[] { typeof(string) });

PoweredSoft.DynamicLinq/Extensions/QueryableExtensions.cs

@@ -86,7 +86,7 @@ namespace PoweredSoft.DynamicLinq
             if (groupBuilder.Empty)
                 throw new Exception("No group specified, please specify at least one group");
 
-            return QueryableHelpers.GroupBy(query, type, groupBuilder.Parts, groupBuilder.Type);
+            return QueryableHelpers.GroupBy(query, type, groupBuilder.Parts, groupBuilder.Type, groupBuilder.EqualityComparerType);
         }
     }
 }

PoweredSoft.DynamicLinq/Fluent/Group/GroupBuilder.cs

@@ -10,6 +10,7 @@ namespace PoweredSoft.DynamicLinq.Fluent
         public List<(string path, string propertyName)> Parts { get; set; } = new List<(string path, string propertyName)>();
         public Type Type { get; set; }
         public bool Empty => !Parts.Any();
+        public Type EqualityComparerType { get; set; }
 
         public GroupBuilder Path(string path, string propertyName = null)
         {
@@ -37,5 +38,11 @@ namespace PoweredSoft.DynamicLinq.Fluent
             Type = type;
             return this;
         }
+
+        public GroupBuilder EqualityComparer(Type type)
+        {
+            EqualityComparerType = type;
+            return this;
+        }
     }
 }

PoweredSoft.DynamicLinq/Helpers/QueryableHelpers.cs

@@ -77,7 +77,7 @@ namespace PoweredSoft.DynamicLinq.Helpers
             return ret;            
         }
 
-        public static IQueryable GroupBy(IQueryable query, Type type, List<(string path, string propertyName)> parts, Type groupToType = null)
+        public static IQueryable GroupBy(IQueryable query, Type type, List<(string path, string propertyName)> parts, Type groupToType = null, Type equalityCompareType = null)
         {
             // EXPRESSION
             var parameter = Expression.Parameter(type, "t");
@@ -93,8 +93,7 @@ namespace PoweredSoft.DynamicLinq.Helpers
                 partExpressions.Add((partExpression, part.propertyName));
             });
 
-            var anonymousType = groupToType ?? TypeHelpers.CreateSimpleAnonymousType(fields);
-
+            var keyType = groupToType ?? TypeHelpers.CreateSimpleAnonymousType(fields);
 
             /*
             var constructorTypes = fields.Select(t => t.type).ToArray();
@@ -105,12 +104,12 @@ namespace PoweredSoft.DynamicLinq.Helpers
             var groupByExpression = Expression.Call(genericMethod, query.Expression, lambda);
             var result = query.Provider.CreateQuery(groupByExpression);*/
 
-            var ctor = Expression.New(anonymousType);
-            var bindings = partExpressions.Select(partExpression => Expression.Bind(anonymousType.GetProperty(partExpression.propertyName), partExpression.expression)).ToList();
+            var ctor = Expression.New(keyType);
+            var bindings = partExpressions.Select(partExpression => Expression.Bind(keyType.GetProperty(partExpression.propertyName), partExpression.expression)).ToList();
             var mi = Expression.MemberInit(ctor, bindings.ToArray());
             var lambda = Expression.Lambda(mi, parameter);
-            var genericMethod = Constants.GroupByMethod.MakeGenericMethod(type, anonymousType);
-            var groupByExpression = Expression.Call(genericMethod, query.Expression, lambda);
+            var genericMethod = equalityCompareType == null ? Constants.GroupByMethod.MakeGenericMethod(type, keyType) : Constants.GroupByMethodWithEqualityComparer.MakeGenericMethod(type, keyType); //, Activator.CreateInstance(equalityCompareType));
+            var groupByExpression = equalityCompareType == null ? Expression.Call(genericMethod, query.Expression, lambda) : Expression.Call(genericMethod, query.Expression, lambda, Expression.New(equalityCompareType));
             var result = query.Provider.CreateQuery(groupByExpression);
             return result;
         }