NH-3964 - normalize linq reflection.

Author: fredericDelaporte

src/NHibernate/Linq/DefaultQueryProvider.cs

@@ -79,17 +79,13 @@ protected virtual NhLinqExpression PrepareQuery(Expression expression, out IQuer
 			return nhLinqExpression;
 		}
 
+		private static readonly MethodInfo Future = ReflectionHelper.GetMethodDefinition<IQuery>(q => q.Future<object>());
+		private static readonly MethodInfo FutureValue = ReflectionHelper.GetMethodDefinition<IQuery>(q => q.FutureValue<object>());
+
 		protected virtual object ExecuteFutureQuery(NhLinqExpression nhLinqExpression, IQuery query, NhLinqExpression nhQuery)
 		{
-			MethodInfo method;
-			if (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence)
-			{
-				method = typeof (IQuery).GetMethod("Future").MakeGenericMethod(nhQuery.Type);
-			}
-			else
-			{
-				method = typeof (IQuery).GetMethod("FutureValue").MakeGenericMethod(nhQuery.Type);
-			}
+			var method = (nhLinqExpression.ReturnType == NhLinqExpressionReturnType.Sequence ? Future : FutureValue)
+				.MakeGenericMethod(nhQuery.Type);
 
 			object result = method.Invoke(query, new object[0]);
 

src/NHibernate/Linq/NhRelinqQueryParser.cs

@@ -50,18 +50,26 @@ public NHibernateNodeTypeProvider()
 		{
 			var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
 
-			methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
-			methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
-			methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
-			methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
+			methodInfoRegistry.Register(
+				new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch<object, object>(null, null)) },
+				typeof(FetchOneExpressionNode));
+			methodInfoRegistry.Register(
+				new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany<object, object>(null, null)) },
+				typeof(FetchManyExpressionNode));
+			methodInfoRegistry.Register(
+				new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch<object, object, object>(null, null)) },
+				typeof(ThenFetchOneExpressionNode));
+			methodInfoRegistry.Register(
+				new[] { ReflectionHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany<object, object, object>(null, null)) },
+				typeof(ThenFetchManyExpressionNode));
 
 			methodInfoRegistry.Register(
 				new[]
-					{
-						typeof(LinqExtensionMethods).GetMethod("Cacheable"),
-						typeof(LinqExtensionMethods).GetMethod("CacheMode"),
-						typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
-					}, typeof(CacheableExpressionNode));
+				{
+					ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.Cacheable<object>(null)),
+					ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheMode<object>(null, CacheMode.Normal)),
+					ReflectionHelper.GetMethodDefinition(() => LinqExtensionMethods.CacheRegion<object>(null, null)),
+				}, typeof(CacheableExpressionNode));
 
 			methodInfoRegistry.Register(
 				new[]

src/NHibernate/Linq/Visitors/ExpressionParameterVisitor.cs

@@ -18,12 +18,19 @@ public class ExpressionParameterVisitor : ExpressionTreeVisitor
 		private readonly Dictionary<ConstantExpression, NamedParameter> _parameters = new Dictionary<ConstantExpression, NamedParameter>();
 		private readonly ISessionFactoryImplementor _sessionFactory;
 
+		private static readonly MethodInfo QueryableSkipDefinition =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.Skip<object>(null, 0));
+		private static readonly MethodInfo QueryableTakeDefinition =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.Take<object>(null, 0));
+		private static readonly MethodInfo EnumerableSkipDefinition =
+			ReflectionHelper.GetMethodDefinition(() => Enumerable.Skip<object>(null, 0));
+		private static readonly MethodInfo EnumerableTakeDefinition =
+			ReflectionHelper.GetMethodDefinition(() => Enumerable.Take<object>(null, 0));
+
 		private readonly ICollection<MethodBase> _pagingMethods = new HashSet<MethodBase>
 			{
-				ReflectionHelper.GetMethodDefinition(() => Queryable.Skip<object>(null, 0)),
-				ReflectionHelper.GetMethodDefinition(() => Queryable.Take<object>(null, 0)),
-				ReflectionHelper.GetMethodDefinition(() => Enumerable.Skip<object>(null, 0)),
-				ReflectionHelper.GetMethodDefinition(() => Enumerable.Take<object>(null, 0)),
+				QueryableSkipDefinition, QueryableTakeDefinition,
+				EnumerableSkipDefinition, EnumerableTakeDefinition
 			};
 
 		public ExpressionParameterVisitor(ISessionFactoryImplementor sessionFactory)

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

@@ -1,19 +1,23 @@
 using System.Linq;
+using System.Reflection;
 using Remotion.Linq.Clauses.ResultOperators;
 
 namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
 {
-    public class ProcessFirst : ProcessFirstOrSingleBase, IResultOperatorProcessor<FirstResultOperator>
-    {
-        public void Process(FirstResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
-        {
-            var firstMethod = resultOperator.ReturnDefaultWhenEmpty
-                                  ? ReflectionHelper.GetMethodDefinition(() => Queryable.FirstOrDefault<object>(null))
-                                  : ReflectionHelper.GetMethodDefinition(() => Queryable.First<object>(null));
+	public class ProcessFirst : ProcessFirstOrSingleBase, IResultOperatorProcessor<FirstResultOperator>
+	{
+		private static readonly MethodInfo FirstOrDefault =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.FirstOrDefault<object>(null));
+		private static readonly MethodInfo First =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.First<object>(null));
 
-            AddClientSideEval(firstMethod, queryModelVisitor, tree);
+		public void Process(FirstResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
+		{
+			var firstMethod = resultOperator.ReturnDefaultWhenEmpty ? FirstOrDefault : First;
 
-						tree.AddTakeClause(tree.TreeBuilder.Constant(1));
-        }
-    }
+			AddClientSideEval(firstMethod, queryModelVisitor, tree);
+
+			tree.AddTakeClause(tree.TreeBuilder.Constant(1));
+		}
+	}
 }

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

@@ -1,17 +1,21 @@
 using System.Linq;
+using System.Reflection;
 using Remotion.Linq.Clauses.ResultOperators;
 
 namespace NHibernate.Linq.Visitors.ResultOperatorProcessors
 {
-    public class ProcessSingle : ProcessFirstOrSingleBase, IResultOperatorProcessor<SingleResultOperator>
-    {
-        public void Process(SingleResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
-        {
-            var firstMethod = resultOperator.ReturnDefaultWhenEmpty
-                                  ? ReflectionHelper.GetMethodDefinition(() => Queryable.SingleOrDefault<object>(null))
-                                  : ReflectionHelper.GetMethodDefinition(() => Queryable.Single<object>(null));
+	public class ProcessSingle : ProcessFirstOrSingleBase, IResultOperatorProcessor<SingleResultOperator>
+	{
+		private static readonly MethodInfo SingleOrDefault =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.SingleOrDefault<object>(null));
+		private static readonly MethodInfo Single =
+			ReflectionHelper.GetMethodDefinition(() => Queryable.Single<object>(null));
 
-            AddClientSideEval(firstMethod, queryModelVisitor, tree);
-        }
-    }
+		public void Process(SingleResultOperator resultOperator, QueryModelVisitor queryModelVisitor, IntermediateHqlTree tree)
+		{
+			var firstMethod = resultOperator.ReturnDefaultWhenEmpty ? SingleOrDefault : Single;
+
+			AddClientSideEval(firstMethod, queryModelVisitor, tree);
+		}
+	}
 }