Add tempSourceString to avoid reevaluation

Author: halter73

src/Http/Http.Extensions/src/RequestDelegateFactory.cs

@@ -40,6 +40,7 @@ public static class RequestDelegateFactory
         private static readonly ParameterExpression HttpContextExpr = Expression.Parameter(typeof(HttpContext), "httpContext");
         private static readonly ParameterExpression BodyValueExpr = Expression.Parameter(typeof(object), "bodyValue");
         private static readonly ParameterExpression WasTryParseFailureExpr = Expression.Variable(typeof(bool), "wasTryParseFailure");
+        private static readonly ParameterExpression TempSourceStringExpr = Expression.Variable(typeof(string), "tempSourceString");
 
         private static readonly MemberExpression RequestServicesExpr = Expression.Property(HttpContextExpr, nameof(HttpContext.RequestServices));
         private static readonly MemberExpression HttpRequestExpr = Expression.Property(HttpContextExpr, nameof(HttpContext.Request));
@@ -277,23 +278,30 @@ private static Expression CreateResponseWritingMethodCall(MethodInfo methodInfo,
         // If we're calling TryParse and the WasTryParseFailureVariable indicates it failed, set a 400 StatusCode instead of calling the method.
         private static Expression CreateTryParseCheckingResponseWritingMethodCall(MethodInfo methodInfo, Expression? target, Expression[] arguments)
         {
+
             // {
-            //     bool wasTryParseFailure = false;
+            //     bool wasTryParseFailureVariable = false;
+            //     string tempSourceString;
             //
             //     // Assume "[FromRoute] int id" is the first parameter.
-            //     int param1 = httpContext.Request.RouteValue["id"] == null ? default :
+            //
+            //     tempSourceString = httpContext.RequestValue["id"];
+            //    
+            //     int param1 = tempSourceString == null ? default :
             //     {
-            //          var sourceValue = httpContext.Request.RouteValue["id"];
             //          int parsedValue = default;
             //
-            //          if (!int.TryParse(sourceValue, out parsedValue))
+            //          if (!int.TryParse(tempSourceString, out parsedValue))
             //          {
-            //              wasTryParseFailure = true;
+            //              wasTryParseFailureVariable = true;
             //              Log.ParameterBindingFailed(httpContext, "Int32", "id", sourceValue)
             //          }
             //
             //          return parsedValue;
             //     };
+            //
+            //     tempSourceString = httpContext.RequestValue["param2"];
+            //     int param2 = tempSourceString == null ? default :
             //     // ...
             //
             //     return wasTryParseFailure ?
@@ -302,20 +310,21 @@ private static Expression CreateTryParseCheckingResponseWritingMethodCall(Method
             //              return Task.CompletedTask;
             //         } :
             //         {
-            //             // Logic generated by AddResponseWritingToMethodCall() that calls action(param1, ...)
+            //             // Logic generated by AddResponseWritingToMethodCall() that calls action(param1, parm2, ...)
             //         };
             // }
 
             var parameters = methodInfo.GetParameters();
             var storedArguments = new ParameterExpression[parameters.Length];
-            var localVariables = new ParameterExpression[parameters.Length + 1];
+            var localVariables = new ParameterExpression[parameters.Length + 2];
 
             for (var i = 0; i < parameters.Length; i++)
             {
                 storedArguments[i] = localVariables[i] = Expression.Parameter(parameters[i].ParameterType);
             }
 
             localVariables[parameters.Length] = WasTryParseFailureExpr;
+            localVariables[parameters.Length + 1] = TempSourceStringExpr;
 
             var assignAndCall = new Expression[parameters.Length + 1];
             for (var i = 0; i < parameters.Length; i++)
@@ -592,74 +601,79 @@ private static Expression GetValueFromProperty(Expression sourceExpression, stri
 
         private static Expression BindParameterFromValue(ParameterInfo parameter, Expression valueExpression, FactoryContext factoryContext)
         {
-            Expression argumentExpression;
-
             if (parameter.ParameterType == typeof(string))
             {
-                argumentExpression = valueExpression;
+                return valueExpression;
             }
-            else
-            {
-                var nonNullableParameterType = Nullable.GetUnderlyingType(parameter.ParameterType) ?? parameter.ParameterType;
-                var tryParseMethod = FindTryParseMethod(nonNullableParameterType);
 
-                if (tryParseMethod is null)
-                {
-                    throw new InvalidOperationException($"No public static bool {parameter.ParameterType.Name}.TryParse(string, out {parameter.ParameterType.Name}) method found for {parameter.Name}.");
-                }
+            var underlyingNullableType = Nullable.GetUnderlyingType(parameter.ParameterType);
+            var nonNullableParameterType = underlyingNullableType ?? parameter.ParameterType;
+            var tryParseMethod = FindTryParseMethod(nonNullableParameterType);
+
+            if (tryParseMethod is null)
+            {
+                throw new InvalidOperationException($"No public static bool {parameter.ParameterType.Name}.TryParse(string, out {parameter.ParameterType.Name}) method found for {parameter.Name}.");
+            }
 
-                // bool wasTryParseFailureVariable = false;
-                //
-                // // Assume "[FromRoute] int id" is the first parameter.
-                // int param1 = httpContext.Request.RouteValue["id"] == null ? default :
-                // {
-                //      var sourceValue = httpContext.Request.RouteValue["id"];
-                //      int parsedValue = default;
-                //
-                //      if (!int.TryParse(sourceValue, out parsedValue))
-                //      {
-                //          wasTryParseFailureVariable = true;
-                //          Log.ParameterBindingFailed(httpContext, "Int32", "id", sourceValue)
-                //      }
-                //
-                //      return parsedValue;
-                // };
+            // bool wasTryParseFailureVariable = false;
+            // string tempSourceString;
+            //
+            // // Assume "[FromRoute] int id" is the first parameter.
+            //
+            // tempSourceString = httpContext.RequestValue["id"];
+            //
+            // int param1 = tempSourceString == null ? default :
+            // {
+            //      int parsedValue = default;
+            //
+            //      if (!int.TryParse(tempSourceString, out parsedValue))
+            //      {
+            //          wasTryParseFailureVariable = true;
+            //          Log.ParameterBindingFailed(httpContext, "Int32", "id", sourceValue)
+            //      }
+            //
+            //      return parsedValue;
+            // };
 
-                factoryContext.CheckForTryParseFailure = true;
+            factoryContext.CheckForTryParseFailure = true;
 
-                var parsedValue = Expression.Variable(nonNullableParameterType);
+            var parsedValue = Expression.Variable(nonNullableParameterType);
 
-                var tryParseCall = Expression.Call(tryParseMethod, valueExpression, parsedValue);
+            var parameterTypeNameConstant = Expression.Constant(parameter.ParameterType.Name);
+            var parameterNameConstant = Expression.Constant(parameter.Name);
 
-                var parameterTypeConstant = Expression.Constant(nonNullableParameterType.Name);
-                var parameterNameConstant = Expression.Constant(parameter.Name);
-                var failBlock = Expression.Block(
-                    Expression.Assign(WasTryParseFailureExpr, Expression.Constant(true)),
-                    Expression.Call(LogParameterBindingFailureMethod,
-                        HttpContextExpr, parameterTypeConstant, parameterNameConstant, valueExpression));
+            var failBlock = Expression.Block(
+                Expression.Assign(WasTryParseFailureExpr, Expression.Constant(true)),
+                Expression.Call(LogParameterBindingFailureMethod,
+                    HttpContextExpr, parameterTypeNameConstant, parameterNameConstant, TempSourceStringExpr));
 
-                var ifFailExpression = Expression.IfThen(Expression.Not(tryParseCall), failBlock);
+            var tryParseCall = Expression.Call(tryParseMethod, TempSourceStringExpr, parsedValue);
+            var ifFailExpression = Expression.IfThen(Expression.Not(tryParseCall), failBlock);
 
-                argumentExpression = Expression.Block(new[] { parsedValue },
-                    ifFailExpression,
-                    parsedValue);
-            }
+            Expression parsedValueExpression = Expression.Block(new[] { parsedValue },
+                ifFailExpression,
+                parsedValue);
 
-            // Convert to nullable if necessary.
-            if (argumentExpression.Type != parameter.ParameterType)
+            // Convert back to nullable if necessary.
+            if (underlyingNullableType is not null)
             {
-                argumentExpression = Expression.Convert(argumentExpression, parameter.ParameterType);
+                parsedValueExpression = Expression.Convert(parsedValueExpression, parameter.ParameterType);
             }
 
             Expression defaultExpression = parameter.HasDefaultValue ?
                 Expression.Constant(parameter.DefaultValue) :
                 Expression.Default(parameter.ParameterType);
 
-            // int param1 = httpContext.Request.RouteValue["id"] == null ? default : ...
-            return Expression.Condition(
-                Expression.Equal(valueExpression, Expression.Constant(null)),
+            // tempSourceString = httpContext.RequestValue["id];
+            var storeValueToTemp = Expression.Assign(TempSourceStringExpr, valueExpression);
+
+            // int param1 = tempSourcString == null ? default : ...
+            var ternary = Expression.Condition(
+                Expression.Equal(TempSourceStringExpr, Expression.Constant(null)),
                 defaultExpression,
-                argumentExpression);
+                parsedValueExpression);
+
+            return Expression.Block(storeValueToTemp, ternary);
         }
 
         private static Expression BindParameterFromProperty(ParameterInfo parameter, MemberExpression property, string key, FactoryContext factoryContext) =>
@@ -828,9 +842,9 @@ public static void RequestBodyInvalidDataException(HttpContext httpContext, Inva
                 _requestBodyInvalidDataException(GetLogger(httpContext), exception);
             }
 
-            public static void ParameterBindingFailed(HttpContext httpContext, string parameterType, string parameterName, string sourceValue)
+            public static void ParameterBindingFailed(HttpContext httpContext, string parameterTypeName, string parameterName, string sourceValue)
             {
-                _parameterBindingFailed(GetLogger(httpContext), parameterType, parameterName, sourceValue, null);
+                _parameterBindingFailed(GetLogger(httpContext), parameterTypeName, parameterName, sourceValue, null);
             }
 
             private static ILogger GetLogger(HttpContext httpContext)