code review fixes

Author: Gokhan Abatay

src/NHibernate/Impl/ExpressionProcessor.cs

@@ -253,8 +253,6 @@ private static ICriterion Le(ProjectionInfo property, object value)
 		public static object FindValue(Expression expression)
 		{
 			object value;
-			object[] args;
-			System.Type type;
 			switch (expression.NodeType)
 			{
 				case ExpressionType.Constant:
@@ -272,54 +270,9 @@ public static object FindValue(Expression expression)
 							return ((PropertyInfo) memberExpression.Member).GetValue(value);
 					}
 					break;
-				case ExpressionType.Convert:
-				case ExpressionType.Not:
-				case ExpressionType.Negate:
-				case ExpressionType.UnaryPlus:
-				case ExpressionType.Decrement:
-				case ExpressionType.Increment:
-					var unaryExpression = (UnaryExpression) expression;
-					value = FindValue(unaryExpression.Operand);
-					switch (expression.NodeType)
-					{
-						case ExpressionType.Convert:
-							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;
-						case ExpressionType.Not:
-							if (value is bool)
-							{
-								return !(dynamic) value;
-							}
-							else
-							{
-								return ~(dynamic) value;
-							}
-						case ExpressionType.Negate:
-							return -(dynamic) value;
-						case ExpressionType.UnaryPlus:
-							return +(dynamic) value;
-						case ExpressionType.Decrement:
-							return (dynamic) value-1;
-						case ExpressionType.Increment:
-							return (dynamic) value+1;
-					}
-					break;
 				case ExpressionType.Call:
 					var methodCallExpression = (MethodCallExpression) expression;
-					args = new object[methodCallExpression.Arguments.Count];
+					var args = new object[methodCallExpression.Arguments.Count];
 					for (int i = 0; i < args.Length; i++)
 						args[i] = FindValue(methodCallExpression.Arguments[i]);
 
@@ -340,132 +293,34 @@ public static object FindValue(Expression expression)
 
 						return methodCallExpression.Method.Invoke(callingObject, args);
 					}
-				case ExpressionType.Multiply:
-				case ExpressionType.Divide:
-				case ExpressionType.Modulo:
-				case ExpressionType.Add:
-				case ExpressionType.Subtract:
-				case ExpressionType.Power:
-				case ExpressionType.AndAlso:
-				case ExpressionType.OrElse:
-				case ExpressionType.And:
-				case ExpressionType.Or:
-				case ExpressionType.ExclusiveOr:
-				case ExpressionType.Equal:
-				case ExpressionType.NotEqual:
-				case ExpressionType.LessThan:
-				case ExpressionType.LessThanOrEqual:
-				case ExpressionType.GreaterThan:
-				case ExpressionType.GreaterThanOrEqual:
-				case ExpressionType.ArrayIndex:
-				case ExpressionType.Coalesce:
-				case ExpressionType.LeftShift:
-				case ExpressionType.RightShift:
-					var binaryExpression = (BinaryExpression) expression;
-					dynamic left = FindValue(binaryExpression.Left);
-					dynamic right = FindValue(binaryExpression.Right);
-					if (binaryExpression.Method != null)
-					{
-						return binaryExpression.Method.Invoke(null, new[] { left, right });
-					}
-					else
-					{
-						switch (expression.NodeType)
-						{
-							case ExpressionType.Multiply:
-								return left * right;
-							case ExpressionType.Divide:
-								return left / right;
-							case ExpressionType.Modulo:
-								return left % right;
-							case ExpressionType.Add:
-								return left + right;
-							case ExpressionType.Subtract:
-								return left - right;
-							case ExpressionType.Power:
-								return left ^ right;
-							case ExpressionType.AndAlso:
-								return left && right;
-							case ExpressionType.OrElse:
-								return left || right;
-							case ExpressionType.And:
-								return left & right;
-							case ExpressionType.Or:
-								return left | right;
-							case ExpressionType.ExclusiveOr:
-								return left ^ right;
-							case ExpressionType.Equal:
-								return left == right;
-							case ExpressionType.NotEqual:
-								return left != right;
-							case ExpressionType.LessThan:
-								return left < right;
-							case ExpressionType.LessThanOrEqual:
-								return left <= right;
-							case ExpressionType.GreaterThan:
-								return left > right;
-							case ExpressionType.GreaterThanOrEqual:
-								return left >= right;
-							case ExpressionType.ArrayIndex:
-								return left[right];
-							case ExpressionType.Coalesce:
-								return left ?? right;
-							case ExpressionType.LeftShift:
-								return left << right;
-							case ExpressionType.RightShift:
-								return left >> right;
-						}
-					}
-					break;
-				case ExpressionType.Conditional:
-					var conditionalExpression = (ConditionalExpression) expression;
-					bool condition = (bool) FindValue(conditionalExpression.Test);
-					if (condition)
-					{
-						return FindValue(conditionalExpression.IfTrue);
-					}
-					else
-					{
-						return FindValue(conditionalExpression.IfFalse);
-					}
-				case ExpressionType.NewArrayInit:
-					var newArrayExpression = (NewArrayExpression) expression;
-					type = newArrayExpression.Type.GetElementType();
-					if (type != null)
+				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)
 					{
-						dynamic array = Array.CreateInstance(type, newArrayExpression.Expressions.Count);
-						for (int i = 0; i< newArrayExpression.Expressions.Count; i++)
-						{
-							array[i] = (dynamic) FindValue(newArrayExpression.Expressions[i]);
-						}
-						return array;
+						return value;
 					}
-					break;
-				case ExpressionType.ListInit:
-					var listInitExpression = (ListInitExpression) expression;
-					var list = Activator.CreateInstance(listInitExpression.Type);
-					foreach (var item in listInitExpression.Initializers)
+					else if (value is IConvertible || unaryExpression.Method != null)
 					{
-						args = new object[item.Arguments.Count];
-						for (int i = 0; i < args.Length; i++)
+						if (type != unaryExpression.Operand.Type)
 						{
-							args[i] = FindValue(item.Arguments[i]);
+							value = unaryExpression.Method != null ? unaryExpression.Method.Invoke(null, new[] { value }) : Convert.ChangeType(value, type);
 						}
 
-						item.AddMethod.Invoke(list, args);
+						return value;
 					}
-					return list;
-				case ExpressionType.New:
-					var newExpression = (NewExpression) expression;
-					args = new object[newExpression.Arguments.Count];
-					for (int i = 0; i < args.Length; i++)
-					{
-						args[i] = FindValue(newExpression.Arguments[i]);
-					}
-					return newExpression.Constructor.Invoke(args);
+					break;
 			}
 
-			return Expression.Lambda(expression).Compile().DynamicInvoke();
+			var valueExpression = Expression.Lambda(expression)
+#if NETCOREAPP2_0_OR_GREATER || NET47_OR_GREATER || NETSTANDARD2_0_OR_GREATER
+                .Compile(true);
+#else
+				.Compile(); //Concurrent Compile() call causes "Garbage Collector" suspend all threads too often
+#endif
+			value = valueExpression.DynamicInvoke();
+			return value;
 		}
 
 		/// <summary>