Remove code duplication in ProcessNonAggregatingGroupBy

Author: hazzik

src/NHibernate/Linq/Visitors/ResultOperatorProcessors/ProcessNonAggregatingGroupBy.cs

@@ -7,71 +7,59 @@
 
 namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
 {
-    public class ProcessNonAggregatingGroupBy : IResultOperatorProcessor<NonAggregatingGroupBy>
-    {
-        public void Process(NonAggregatingGroupBy resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
-        {
-            var tSource = queryModelVisitor.Model.SelectClause.Selector.Type;
-            var tKey = resultOperator.GroupBy.KeySelector.Type;
-            var tElement = resultOperator.GroupBy.ElementSelector.Type;
+	public class ProcessNonAggregatingGroupBy : IResultOperatorProcessor<NonAggregatingGroupBy>
+	{
+		public void Process(NonAggregatingGroupBy resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
+		{
+			var tSource = queryModelVisitor.Model.SelectClause.Selector.Type;
+			var tKey = resultOperator.GroupBy.KeySelector.Type;
+			var tElement = resultOperator.GroupBy.ElementSelector.Type;
 
-            // Stuff in the group by that doesn't map to HQL.  Run it client-side
-            var listParameter = Expression.Parameter(typeof(IEnumerable<object>), "list");
+			// Stuff in the group by that doesn't map to HQL.  Run it client-side
+			var listParameter = Expression.Parameter(typeof(IEnumerable<object>), "list");
 
-            ParameterExpression itemParam = Expression.Parameter(tSource, "item");
-            Expression keySelectorSource = itemParam;
+			var keySelectorExpr = CreateSelector(tSource, resultOperator.GroupBy.KeySelector);
 
-            if (tSource != SourceOf(resultOperator.GroupBy.KeySelector))
-            {
-                keySelectorSource = Expression.MakeMemberAccess(itemParam,
-                                                                tSource.GetMember(
-                                                                    ((QuerySourceReferenceExpression)
-                                                                     resultOperator.GroupBy.KeySelector).ReferencedQuerySource.
-                                                                        ItemName)[0]);
-            }
+			var elementSelectorExpr = CreateSelector(tSource, resultOperator.GroupBy.ElementSelector);
 
+			var groupByMethod = EnumerableHelper.GetMethod("GroupBy",
+														   new[] { typeof(IEnumerable<>), typeof(Func<,>), typeof(Func<,>) },
+														   new[] { tSource, tKey, tElement });
 
-            Expression keySelector = new GroupByKeySelectorVisitor(keySelectorSource).Visit(resultOperator.GroupBy.KeySelector);
+			var castToItem = EnumerableHelper.GetMethod("Cast", new[] { typeof(IEnumerable) }, new[] { tSource });
 
-            Expression elementSelectorSource = itemParam;
+			var toList = EnumerableHelper.GetMethod("ToList", new[] { typeof(IEnumerable<>) }, new[] { resultOperator.GroupBy.ItemType });
 
-            if (tSource != SourceOf(resultOperator.GroupBy.ElementSelector))
-            {
-                elementSelectorSource = Expression.MakeMemberAccess(itemParam,
-                                                                    tSource.GetMember(
-                                                                        ((QuerySourceReferenceExpression)
-                                                                         resultOperator.GroupBy.ElementSelector).ReferencedQuerySource.
-                                                                            ItemName)[0]);
-            }
+			Expression castToItemExpr = Expression.Call(castToItem, listParameter);
 
-            Expression elementSelector = new GroupByKeySelectorVisitor(elementSelectorSource).Visit(resultOperator.GroupBy.ElementSelector);
+			var groupByExpr = Expression.Call(groupByMethod, castToItemExpr, keySelectorExpr, elementSelectorExpr);
 
-            var groupByMethod = EnumerableHelper.GetMethod("GroupBy",
-                                                           new[] { typeof(IEnumerable<>), typeof(Func<,>), typeof(Func<,>) },
-                                                           new[] { tSource, tKey, tElement });
+			var toListExpr = Expression.Call(toList, groupByExpr);
 
-            var castToItem = EnumerableHelper.GetMethod("Cast", new[] { typeof(IEnumerable) }, new[] { tSource });
+			var lambdaExpr = Expression.Lambda(toListExpr, listParameter);
 
-            var toList = EnumerableHelper.GetMethod("ToList", new[] { typeof(IEnumerable<>) }, new[] { resultOperator.GroupBy.ItemType });
+			tree.AddListTransformer(lambdaExpr);
+		}
 
-            LambdaExpression keySelectorExpr = Expression.Lambda(keySelector, itemParam);
+		private static LambdaExpression CreateSelector(System.Type sourceType, Expression selector)
+		{
+			var parameter = Expression.Parameter(sourceType, "item");
+			var selectorSource = (Expression) parameter;
 
-            LambdaExpression elementSelectorExpr = Expression.Lambda(elementSelector, itemParam);
+			if (sourceType != SourceOf(selector))
+			{
+				var member = sourceType.GetMember(((QuerySourceReferenceExpression) selector).ReferencedQuerySource.ItemName)[0];
 
-            Expression castToItemExpr = Expression.Call(castToItem, listParameter);
+				selectorSource = Expression.MakeMemberAccess(parameter, member);
+			}
 
-            var groupByExpr = Expression.Call(groupByMethod, castToItemExpr, keySelectorExpr, elementSelectorExpr);
+			var keySelector = new GroupByKeySelectorVisitor(selectorSource).Visit(selector);
+			return Expression.Lambda(keySelector, parameter);
+		}
 
-            var toListExpr = Expression.Call(toList, groupByExpr);
-
-            var lambdaExpr = Expression.Lambda(toListExpr, listParameter);
-
-            tree.AddListTransformer(lambdaExpr);
-        }
-
-        private static System.Type SourceOf(Expression keySelector)
-        {
-            return new GroupByKeySourceFinder().Visit(keySelector).Type;
-        }
-    }
-}
+		private static System.Type SourceOf(Expression keySelector)
+		{
+			return new GroupByKeySourceFinder().Visit(keySelector).Type;
+		}
+	}
+}