Optimize LINQ batch item processing for queries with overridden result type

src/NHibernate/Async/Multi/LinqBatchItem.cs

@@ -14,15 +14,14 @@
 using System.Linq;
 using System.Linq.Expressions;
 using NHibernate.Linq;
-using NHibernate.Util;
 using Remotion.Linq.Parsing.ExpressionVisitors;
 
 namespace NHibernate.Multi
 {
 	using System.Threading.Tasks;
 	using System.Threading;
 
-	public partial class LinqBatchItem<T> : QueryBatchItem<T>
+	public partial class LinqBatchItem<T> : QueryBatchItem<T>, ILinqBatchItem
 	{
 
 		protected override async Task<IList<T>> GetResultsNonBatchedAsync(CancellationToken cancellationToken)

src/NHibernate/Multi/LinqBatchItem.cs

@@ -4,11 +4,15 @@
 using System.Linq;
 using System.Linq.Expressions;
 using NHibernate.Linq;
-using NHibernate.Util;
 using Remotion.Linq.Parsing.ExpressionVisitors;
 
 namespace NHibernate.Multi
 {
+	interface ILinqBatchItem
+	{
+		List<TResult> GetTypedResults<TResult>();
+	}
+
 	public static class LinqBatchItem
 	{
 		public static LinqBatchItem<TResult> Create<T, TResult>(IQueryable<T> query, Expression<Func<IQueryable<T>, TResult>> selector)
@@ -42,9 +46,10 @@ private static LinqBatchItem<TResult> GetForQuery<TResult>(IQueryable query, Exp
 	/// Create instance via <see cref="LinqBatchItem.Create"/> methods
 	/// </summary>
 	/// <typeparam name="T">Result type</typeparam>
-	public partial class LinqBatchItem<T> : QueryBatchItem<T>
+	public partial class LinqBatchItem<T> : QueryBatchItem<T>, ILinqBatchItem
 	{
 		private readonly Delegate _postExecuteTransformer;
+		private readonly System.Type _resultTypeOverride;
 
 		public LinqBatchItem(IQuery query) : base(query)
 		{
@@ -53,6 +58,7 @@ public LinqBatchItem(IQuery query) : base(query)
 		internal LinqBatchItem(IQuery query, NhLinqExpression linq) : base(query)
 		{
 			_postExecuteTransformer = linq.ExpressionToHqlTranslationResults.PostExecuteTransformer;
+			_resultTypeOverride = linq.ExpressionToHqlTranslationResults.ExecuteResultTypeOverride;
 		}
 
 		protected override IList<T> GetResultsNonBatched()
@@ -69,11 +75,10 @@ protected override List<T> DoGetResults()
 		{
 			if (_postExecuteTransformer != null)
 			{
-				var elementType = GetResultTypeIfChanged();
-
-				IList transformerList = elementType == null
+				IList transformerList = _resultTypeOverride == null
 					? base.DoGetResults()
-					: GetTypedResults(elementType);
+					//see LinqToFutureValueFixture tests that cover this scenario
+					: LinqBatchReflectHelper.GetTypedResults(this, _resultTypeOverride);
 
 				return GetTransformedResults(transformerList);
 			}
@@ -90,27 +95,9 @@ private List<T> GetTransformedResults(IList transformerList)
 			};
 		}
 
-		private System.Type GetResultTypeIfChanged()
-		{
-			if (_postExecuteTransformer == null)
-			{
-				return null;
-			}
-			var elementType = _postExecuteTransformer.Method.GetParameters()[1].ParameterType.GetGenericArguments()[0];
-			if (typeof(T).IsAssignableFrom(elementType))
-			{
-				return null;
-			}
-
-			return elementType;
-		}
-
-		private IList GetTypedResults(System.Type type)
+		List<TResult> ILinqBatchItem.GetTypedResults<TResult>()
 		{
-			var method = ReflectHelper.GetMethod(() => GetTypedResults<T>())
-									.GetGenericMethodDefinition();
-			var generic = method.MakeGenericMethod(type);
-			return (IList) generic.Invoke(this, null);
+			return GetTypedResults<TResult>();
 		}
 	}
 }

src/NHibernate/Multi/LinqBatchReflectHelper.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Reflection;
+using NHibernate.Util;
+
+namespace NHibernate.Multi
+{
+	static class LinqBatchReflectHelper
+	{
+		private static readonly ConcurrentDictionary<System.Type, Func<ILinqBatchItem, IList>> GetResultsForTypeDic = new ConcurrentDictionary<System.Type, Func<ILinqBatchItem, IList>>();
+
+		private static readonly MethodInfo GetTypedResultsMethod = ReflectHelper.GetMethod((ILinqBatchItem i) => i.GetTypedResults<object>()).GetGenericMethodDefinition();
+
+		internal static IList GetTypedResults(ILinqBatchItem batchItem, System.Type type)
+		{
+			return GetResultsForTypeDic.GetOrAdd(type, t => CompileDelegate(t)).Invoke(batchItem);
+		}
+
+		private static Func<ILinqBatchItem, IList> CompileDelegate(System.Type type)
+		{
+			var generic = GetTypedResultsMethod.MakeGenericMethod(type);
+			var instance = Expression.Parameter(typeof(ILinqBatchItem));
+			var methodCall = Expression.Call(instance, generic);
+			return Expression.Lambda<Func<ILinqBatchItem, IList>>(methodCall, instance).Compile();
+		}
+	}
+}