Infer that interface parameters are services

Author: halter73

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

@@ -203,15 +203,7 @@ private static Expression CreateArgument(ParameterInfo parameter, FactoryContext
             }
             else if (parameterCustomAttributes.OfType<IFromBodyMetadata>().FirstOrDefault() is { } bodyAttribute)
             {
-                if (factoryContext.JsonRequestBodyType is not null)
-                {
-                    throw new InvalidOperationException("Action cannot have more than one FromBody attribute.");
-                }
-
-                factoryContext.JsonRequestBodyType = parameter.ParameterType;
-                factoryContext.AllowEmptyRequestBody = bodyAttribute.AllowEmpty;
-
-                return Expression.Convert(BodyValueExpr, parameter.ParameterType);
+                return BindParameterFromBody(parameter.ParameterType, bodyAttribute.AllowEmpty, factoryContext);
             }
             else if (parameter.CustomAttributes.Any(a => typeof(IFromServiceMetadata).IsAssignableFrom(a.AttributeType)))
             {
@@ -229,10 +221,14 @@ private static Expression CreateArgument(ParameterInfo parameter, FactoryContext
             {
                 return BindParameterFromRouteValueOrQueryString(parameter, parameter.Name, factoryContext);
             }
-            else
+            else if (parameter.ParameterType.IsInterface)
             {
                 return Expression.Call(GetRequiredServiceMethod.MakeGenericMethod(parameter.ParameterType), RequestServicesExpr);
             }
+            else
+            {
+                return BindParameterFromBody(parameter.ParameterType, allowEmpty: false, factoryContext);
+            }
         }
 
         private static Expression CreateMethodCall(MethodInfo methodInfo, Expression? target, Expression[] arguments) =>
@@ -627,6 +623,19 @@ private static Expression BindParameterFromRouteValueOrQueryString(ParameterInfo
             return BindParameterFromValue(parameter, Expression.Coalesce(routeValue, queryValue), factoryContext);
         }
 
+        private static Expression BindParameterFromBody(Type parameterType, bool allowEmpty, FactoryContext factoryContext)
+        {
+            if (factoryContext.JsonRequestBodyType is not null)
+            {
+                throw new InvalidOperationException("Action cannot have more than one FromBody attribute.");
+            }
+
+            factoryContext.JsonRequestBodyType = parameterType;
+            factoryContext.AllowEmptyRequestBody = allowEmpty;
+
+            return Expression.Convert(BodyValueExpr, parameterType);
+        }
+
         private static MethodInfo GetMethodInfo<T>(Expression<T> expr)
         {
             var mc = (MethodCallExpression)expr.Body;

src/Http/Http.Extensions/test/RequestDelegateFactoryTests.cs

@@ -416,7 +416,7 @@ public async Task RequestDelegatePopulatesUnattributedTryParsableParametersFromR
             Assert.Equal(42, httpContext.Items["tryParsable"]);
         }
 
-        public static object[][] DelegatesWithInvalidAttributes
+        public static object[][] DelegatesWithAttributesOnNotTryParsableParameters
         {
             get
             {
@@ -434,7 +434,7 @@ void InvalidFromHeader([FromHeader] object notTryParsable) { }
         }
 
         [Theory]
-        [MemberData(nameof(DelegatesWithInvalidAttributes))]
+        [MemberData(nameof(DelegatesWithAttributesOnNotTryParsableParameters))]
         public void CreateThrowsInvalidOperationExceptionWhenAttributeRequiresTryParseMethodThatDoesNotExist(Delegate action)
         {
             var ex = Assert.Throws<InvalidOperationException>(() => RequestDelegateFactory.Create(action));
@@ -719,11 +719,13 @@ void TestAction([FromBody] Todo todo)
         [Fact]
         public void BuildRequestDelegateThrowsInvalidOperationExceptionGivenFromBodyOnMultipleParameters()
         {
-            void TestExplicitlyInvalidAction([FromBody] int value1, [FromBody] int value2) { }
+            void TestAttributedInvalidAction([FromBody] int value1, [FromBody] int value2) { }
             void TestInferredInvalidAction(Todo value1, Todo value2) { }
+            void TestBothInvalidAction(Todo value1, [FromBody] int value2) { }
 
-            Assert.Throws<InvalidOperationException>(() => RequestDelegateFactory.Create((Action<int, int>)TestExplicitlyInvalidAction));
+            Assert.Throws<InvalidOperationException>(() => RequestDelegateFactory.Create((Action<int, int>)TestAttributedInvalidAction));
             Assert.Throws<InvalidOperationException>(() => RequestDelegateFactory.Create((Action<Todo, Todo>)TestInferredInvalidAction));
+            Assert.Throws<InvalidOperationException>(() => RequestDelegateFactory.Create((Action<Todo, int>)TestBothInvalidAction));
         }
 
         public static object[][] FromServiceActions