Avoid lambda compilation as much as possible

src/NHibernate.Test/Criteria/Lambda/ExpressionProcessorFindValueFixture.cs

@@ -0,0 +1,292 @@
+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+using NHibernate.Impl;
+using NUnit.Framework;
+
+namespace NHibernate.Test.Criteria.Lambda
+{
+	public static class DateTimeExtensions
+	{
+		public static long ToLongDateTime(this DateTime date)
+		{
+			return Convert.ToInt64(date.ToString("yyyyMMddHHmmss"));
+		}
+	}
+
+	[TestFixture]
+	public class ExpressionProcessorFindValueFixture
+	{
+		private static object GetValue<T>(Expression<Func<T>> expression)
+		{
+			try
+			{
+				return ExpressionProcessor.FindValue(expression.Body);
+			}
+			catch (TargetInvocationException e)
+			{
+				throw e.InnerException;
+			}
+		}
+
+		private static int GetIntegerDate()
+		{
+			return Convert.ToInt32(DateTime.Now.ToString("yyyyMMdd"));
+		}
+
+		[Test]
+		public void StaticPropertyInstanceMethodCall()
+		{
+			var actual = GetValue(() => DateTime.Now.ToString("yyyyMMdd"));
+			var expected = DateTime.Now.ToString("yyyyMMdd");
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void StaticPropertyInstanceMultipleMethodCall()
+		{
+			var actual = GetValue(() => DateTime.Now.AddDays(365).ToString("yyyyMMdd"));
+			var expected = DateTime.Now.AddDays(365).ToString("yyyyMMdd");
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void StaticPropertyInstanceMethodCallThenCast()
+		{
+			var actual = GetValue(() => Convert.ToInt32(DateTime.Now.AddDays(365).ToString("yyyyMMdd")));
+			var expected = Convert.ToInt32(DateTime.Now.AddDays(365).ToString("yyyyMMdd"));
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void StaticMethodCall()
+		{
+			var actual = GetValue(() => GetIntegerDate());
+			var expected = GetIntegerDate();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void ExtensionMethodCall()
+		{
+			var date = DateTime.Now;
+			var actual = GetValue(() => date.ToLongDateTime());
+			var expected = date.ToLongDateTime();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NestedPropertyAccess()
+		{
+			var animal = new { Snake = new { Animal = new { Name = "Scorpion" } } };
+			var actual = GetValue(() => animal.Snake.Animal.Name);
+			var expected = animal.Snake.Animal.Name;
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void GuidToStringCast()
+		{
+			var guid = Guid.NewGuid();
+			Expression<Func<string>> expression = () => $"{guid}";
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NestedPropertyToIntegerCast()
+		{
+			var animal = new { Snake = new { Animal = new { Weight = 9.89 } } };
+			Expression<Func<int>> expression = () => (int) animal.Snake.Animal.Weight;
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NestedPropertyToIntegerConvert()
+		{
+			var animal = new { Snake = new { Animal = new { Weight = 9.89 } } };
+			Expression<Func<int>> expression = () => Convert.ToInt32(animal.Snake.Animal.Weight);
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NullToIntegerCastFails()
+		{
+			object value = null;
+			Expression<Func<int>> expression = () => (int) value;
+
+			Assert.Throws<NullReferenceException>(() => GetValue(expression));
+
+			//Check with expression compile and invoke
+			Assert.Throws<NullReferenceException>(() => expression.Compile().Invoke());
+		}
+
+		[Test]
+		public void NullableIntegerToIntegerCastFails()
+		{
+			int? value = null;
+			Expression<Func<int>> expression = () => (int) value;
+
+			Assert.Throws<InvalidOperationException>(() => GetValue(expression));
+
+			//Check with expression compile and invoke
+			Assert.Throws<InvalidOperationException>(() => expression.Compile().Invoke());
+		}
+
+		[Test]
+		public void NullableIntegerToIntegerCast()
+		{
+			int? value = 1;
+			Expression<Func<int>> expression = () => (int) value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NullableIntegerToNullableLongImplicitCast()
+		{
+			int? value = 1;
+			Expression<Func<long?>> expression = () => value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void IntegerToIntegerCast()
+		{
+			int value = 1;
+			Expression<Func<int>> expression = () => (int) value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void IntegerToNullableIntegerImplicitCast()
+		{
+			int value = 12345;
+			Expression<Func<int?>> expression = () => value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void IntegerToNullableLongImplicitCast()
+		{
+			int value = 12345;
+			Expression<Func<long?>> expression = () => value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void IntegerToNullableDecimalImplicitCast()
+		{
+			int value = 12345;
+			Expression<Func<decimal?>> expression = () => value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void Int16ToIntegerImplicitCast()
+		{
+			short value = 12345;
+			Expression<Func<int>> expression = () => value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void NullableDecimalToDecimalCast()
+		{
+			decimal? value = 9.89m;
+			Expression<Func<decimal>> expression = () => (decimal) value;
+
+			var actual = GetValue(expression);
+
+			//Check with expression compile and invoke
+			var expected = expression.Compile().Invoke();
+
+			Assert.AreEqual(expected, actual);
+		}
+
+		[Test]
+		public void StringToIntegerCastFails()
+		{
+			object value = "Abatay";
+			Expression<Func<int>> expression = () => (int) value;
+
+			Assert.Throws<InvalidCastException>(() => GetValue(expression));
+
+			//Check with expression compile and invoke
+			Assert.Throws<InvalidCastException>(() => expression.Compile().Invoke());
+		}
+
+		[Test]
+		public void BooleanToCharCastFails()
+		{
+			object isTrue = true;
+			Expression<Func<char>> expression = () => (char) isTrue;
+
+			Assert.Throws<InvalidCastException>(() => GetValue(expression));
+
+			//Check with expression compile and invoke
+			Assert.Throws<InvalidCastException>(() => expression.Compile().Invoke());
+		}
+	}
+}

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -248,32 +248,55 @@ 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;
+			object findValue(Expression e) => e != null ? FindValue(e) : null;
 
-			if (expression.NodeType == ExpressionType.MemberAccess)
+			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;
+					switch (memberExpression.Member.MemberType)
 					{
 						case MemberTypes.Field:
-							return ((FieldInfo) member).GetValue(constantValue);
+							return ((FieldInfo) memberExpression.Member).GetValue(findValue(memberExpression.Expression));
 						case MemberTypes.Property:
-							return ((PropertyInfo) member).GetValue(constantValue);
+							return ((PropertyInfo) memberExpression.Member).GetValue(findValue(memberExpression.Expression));
 					}
-				}
+					break;
+				case ExpressionType.Call:
+					var methodCallExpression = (MethodCallExpression) expression;
+					var args = methodCallExpression.Arguments.ToArray(arg => FindValue(arg));
+					var callingObject = findValue(methodCallExpression.Object);
+					return methodCallExpression.Method.Invoke(callingObject, args);
+				case ExpressionType.Convert:
+					var unaryExpression = (UnaryExpression) expression;
+
+					if (unaryExpression.Method != null)
+						return unaryExpression.Method.Invoke(null, new[] { FindValue(unaryExpression.Operand) });
+
+					var toType = unaryExpression.Type;
+					var fromType = unaryExpression.Operand.Type;
+					if (toType == typeof(object) || toType == fromType || Nullable.GetUnderlyingType(toType) == fromType)
+						return FindValue(unaryExpression.Operand);
+
+					if (toType == Nullable.GetUnderlyingType(fromType))
+					{
+						var val = FindValue(unaryExpression.Operand);
+						if (val != null)
+							return val;
+					}
+
+					break;
 			}
 
-			var valueExpression = Expression.Lambda(expression).Compile();
-			object value = valueExpression.DynamicInvoke();
+			var lambdaExpression = Expression.Lambda(expression).Compile(true);
+			var value = lambdaExpression.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
+}