Avoid lambda compilation as much as possible, concurrent Compile() call causes "Garbage Collector" suspend all threads too often

Author: Gokhan Abatay

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -248,32 +248,73 @@ private static ICriterion Le(ProjectionInfo property, object value)
 		}
 
 		/// <summary>
-		/// Invoke the expression to extract its runtime value
+		/// Walk or Invoke expression to extract its runtime value
 		/// </summary>
 		public static object FindValue(Expression expression)
 		{
-			if (expression.NodeType == ExpressionType.Constant)
-				return ((ConstantExpression) expression).Value;
-
-			if (expression.NodeType == ExpressionType.MemberAccess)
+			object value;
+			switch (expression.NodeType)
 			{
-				var memberAccess = (MemberExpression) expression;
-				if (memberAccess.Expression == null || memberAccess.Expression.NodeType == ExpressionType.Constant)
-				{
-					var constantValue = ((ConstantExpression) memberAccess.Expression)?.Value;
-					var member = memberAccess.Member;
-					switch (member.MemberType)
+				case ExpressionType.Constant:
+					var constantExpression = (ConstantExpression) expression;
+					return constantExpression.Value;
+				case ExpressionType.MemberAccess:
+					var memberExpression = (MemberExpression) expression;
+					value = memberExpression.Expression != null ? FindValue(memberExpression.Expression) : null;
+
+					switch (memberExpression.Member.MemberType)
 					{
 						case MemberTypes.Field:
-							return ((FieldInfo) member).GetValue(constantValue);
+							return ((FieldInfo) memberExpression.Member).GetValue(value);
 						case MemberTypes.Property:
-							return ((PropertyInfo) member).GetValue(constantValue);
+							return ((PropertyInfo) memberExpression.Member).GetValue(value);
 					}
-				}
+					break;
+				case ExpressionType.Call:
+					var methodCallExpression = (MethodCallExpression) expression;
+					var args = new object[methodCallExpression.Arguments.Count];
+					for (int i = 0; i < args.Length; i++)
+						args[i] = FindValue(methodCallExpression.Arguments[i]);
+
+					if (methodCallExpression.Object == null) //extension or static method
+					{
+						if (args.Length > 0 && args[0] != null)
+						{
+							return methodCallExpression.Method.Invoke(args[0].GetType(), args);
+						}
+						else
+						{
+							return methodCallExpression.Method.Invoke(methodCallExpression.Method.DeclaringType, args);
+						}
+					}
+					else
+					{
+						var callingObject = FindValue(methodCallExpression.Object);
+
+						return methodCallExpression.Method.Invoke(callingObject, args);
+					}
+				case ExpressionType.Convert:
+					var unaryExpression = (UnaryExpression) expression;
+					value = FindValue(unaryExpression.Operand);
+					var type = Nullable.GetUnderlyingType(unaryExpression.Type) ?? unaryExpression.Type;
+					if (type == typeof(object) || value == null)
+					{
+						return value;
+					}
+					else if (value is IConvertible || unaryExpression.Method != null)
+					{
+						if (type != unaryExpression.Operand.Type)
+						{
+							value = unaryExpression.Method != null ? unaryExpression.Method.Invoke(null, new[] { value }) : Convert.ChangeType(value, type);
+						}
+
+						return value;
+					}
+					break;
 			}
 
-			var valueExpression = Expression.Lambda(expression).Compile();
-			object value = valueExpression.DynamicInvoke();
+			var valueExpression = Expression.Lambda(expression).Compile(true);
+			value = valueExpression.DynamicInvoke();
 			return value;
 		}
 

src/NHibernate/Impl/LambdaExpressionExtensions.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Linq.Expressions;
+
+namespace NHibernate.Impl
+{
+#if NET461
+	internal static class LambdaExpressionExtensions
+	{
+		public static Delegate Compile(this LambdaExpression expression, bool preferInterpretation) =>
+		  expression.Compile(); //Concurrent Compile() call causes "Garbage Collector" suspend all threads too often
+	}
+#endif
+}

src/NHibernate/Linq/Visitors/ExpressionParameterVisitor.cs

@@ -5,6 +5,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using NHibernate.Engine;
+using NHibernate.Impl;
 using NHibernate.Linq.Functions;
 using NHibernate.Param;
 using NHibernate.Type;
@@ -150,12 +151,10 @@ protected override Expression VisitUnary(UnaryExpression node)
 			    node.Method != null && // The implicit/explicit operator method
 			    node.Operand is ConstantExpression constantExpression)
 			{
-				// Instead of getting constantExpression.Value, we override the value by compiling and executing this subtree,
-				// performing the cast.
-				var lambda = Expression.Lambda<Func<object>>(Expression.Convert(node, typeof(object)));
-				var compiledLambda = lambda.Compile();
+				// Instead of getting constantExpression.Value, we override the value with ExpressionProcessor
+				var value = ExpressionProcessor.FindValue(node);
 
-				AddConstantExpressionParameter(constantExpression, compiledLambda());
+				AddConstantExpressionParameter(constantExpression, value);
 			}
 
 			return base.VisitUnary(node);