Add new BuildRequestDelegate overloads

halter73 · halter73 · commit 23cedcab162f · 2021-03-24T22:23:28.000-07:00
diff --git a/src/Http/Http.Extensions/src/PublicAPI.Unshipped.txt b/src/Http/Http.Extensions/src/PublicAPI.Unshipped.txt
@@ -170,6 +170,8 @@ static Microsoft.AspNetCore.Http.HeaderDictionaryTypeExtensions.GetTypedHeaders(
 static Microsoft.AspNetCore.Http.HeaderDictionaryTypeExtensions.GetTypedHeaders(this Microsoft.AspNetCore.Http.HttpResponse! response) -> Microsoft.AspNetCore.Http.Headers.ResponseHeaders!
 static Microsoft.AspNetCore.Http.HttpContextServerVariableExtensions.GetServerVariable(this Microsoft.AspNetCore.Http.HttpContext! context, string! variableName) -> string?
 static Microsoft.AspNetCore.Http.RequestDelegateBuilder.BuildRequestDelegate(System.Delegate! action) -> Microsoft.AspNetCore.Http.RequestDelegate!
+static Microsoft.AspNetCore.Http.RequestDelegateBuilder.BuildRequestDelegate(System.Reflection.MethodInfo! methodInfo) -> Microsoft.AspNetCore.Http.RequestDelegate!
+static Microsoft.AspNetCore.Http.RequestDelegateBuilder.BuildRequestDelegate(System.Reflection.MethodInfo! methodInfo, System.Func<Microsoft.AspNetCore.Http.HttpContext!, object!>! targetFactory) -> Microsoft.AspNetCore.Http.RequestDelegate!
 static Microsoft.AspNetCore.Http.ResponseExtensions.Clear(this Microsoft.AspNetCore.Http.HttpResponse! response) -> void
 static Microsoft.AspNetCore.Http.ResponseExtensions.Redirect(this Microsoft.AspNetCore.Http.HttpResponse! response, string! location, bool permanent, bool preserveMethod) -> void
 static Microsoft.AspNetCore.Http.SendFileResponseExtensions.SendFileAsync(this Microsoft.AspNetCore.Http.HttpResponse! response, Microsoft.Extensions.FileProviders.IFileInfo! file, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task!
diff --git a/src/Http/Http.Extensions/src/RequestDelegateBuilder.cs b/src/Http/Http.Extensions/src/RequestDelegateBuilder.cs
@@ -52,6 +52,80 @@ public static class RequestDelegateBuilder
         /// <param name="action">A request handler with any number of custom parameters that often produces a response with its return value.</param>
         /// <returns>The <see cref="RequestDelegate"/></returns>
         public static RequestDelegate BuildRequestDelegate(Delegate action)
+        {
+            if (action is null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            var targetExpression = action.Target switch
+            {
+                { } => Expression.Convert(TargetArg, action.Target.GetType()),
+                null => null,
+            };
+
+            var untargetedRequestDelegate = BuildRequestDelegate(action.Method, targetExpression);
+
+            return httpContext =>
+            {
+                return untargetedRequestDelegate(action.Target, httpContext);
+            };
+        }
+
+        /// <summary>
+        /// Builds a <see cref="RequestDelegate"/> implementation for <paramref name="methodInfo"/>.
+        /// </summary>
+        /// <param name="methodInfo">A static request handler with any number of custom parameters that often produces a response with its return value.</param>
+        /// <returns>The <see cref="RequestDelegate"/></returns>
+        public static RequestDelegate BuildRequestDelegate(MethodInfo methodInfo)
+        {
+            if (methodInfo is null)
+            {
+                throw new ArgumentNullException(nameof(methodInfo));
+            }
+
+            var untargetedRequestDelegate = BuildRequestDelegate(methodInfo, targetExpression: null);
+
+            return httpContext =>
+            {
+                return untargetedRequestDelegate(null, httpContext);
+            };
+        }
+
+
+        /// <summary>
+        /// Builds a <see cref="RequestDelegate"/> implementation for <paramref name="methodInfo"/>.
+        /// </summary>
+        /// <param name="methodInfo">A request handler with any number of custom parameters that often produces a response with its return value.</param>
+        /// <param name="targetFactory">Creates the <see langword="this"/> for the non-static method. If the </param>
+        /// <returns>The <see cref="RequestDelegate"/></returns>
+        public static RequestDelegate BuildRequestDelegate(MethodInfo methodInfo, Func<HttpContext, object> targetFactory)
+        {
+            if (methodInfo is null)
+            {
+                throw new ArgumentNullException(nameof(methodInfo));
+            }
+
+            if (targetFactory is null)
+            {
+                throw new ArgumentNullException(nameof(targetFactory));
+            }
+
+            if (methodInfo.DeclaringType is null)
+            {
+                throw new ArgumentException($"A {nameof(targetFactory)} was provided, but {nameof(methodInfo)} does not have a Declaring type.");
+            }
+
+            var targetExpression = Expression.Convert(TargetArg, methodInfo.DeclaringType);
+            var untargetedRequestDelegate = BuildRequestDelegate(methodInfo, targetExpression);
+
+            return httpContext =>
+            {
+                return untargetedRequestDelegate(targetFactory(httpContext), httpContext);
+            };
+        }
+
+        private static Func<object?, HttpContext, Task> BuildRequestDelegate(MethodInfo methodInfo, Expression? targetExpression)
         {
             // Non void return type
 
@@ -69,8 +143,6 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
             //     return default;
             // }
 
-            var method = action.Method;
-
             var consumeBodyDirectly = false;
             var consumeBodyAsForm = false;
             Type? bodyType = null;
@@ -79,7 +151,7 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
             // This argument represents the deserialized body returned from IHttpRequestReader
             // when the method has a FromBody attribute declared
 
-            var methodParameters = method.GetParameters();
+            var methodParameters = methodInfo.GetParameters();
             var args = new List<Expression>(methodParameters.Length);
 
             foreach (var parameter in methodParameters)
@@ -163,18 +235,17 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
 
             MethodCallExpression methodCall;
 
-            if (action.Target is null)
+            if (targetExpression is null)
             {
-                methodCall = Expression.Call(method, args);
+                methodCall = Expression.Call(methodInfo, args);
             }
             else
             {
-                var castedTarget = Expression.Convert(TargetArg, action.Target.GetType());
-                methodCall = Expression.Call(castedTarget, method, args);
+                methodCall = Expression.Call(targetExpression, methodInfo, args);
             }
 
             // Exact request delegate match
-            if (method.ReturnType == typeof(void))
+            if (methodInfo.ReturnType == typeof(void))
             {
                 var bodyExpressions = new List<Expression>
                 {
@@ -184,22 +255,22 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
 
                 body = Expression.Block(bodyExpressions);
             }
-            else if (AwaitableInfo.IsTypeAwaitable(method.ReturnType, out var info))
+            else if (AwaitableInfo.IsTypeAwaitable(methodInfo.ReturnType, out var info))
             {
-                if (method.ReturnType == typeof(Task))
+                if (methodInfo.ReturnType == typeof(Task))
                 {
                     body = methodCall;
                 }
-                else if (method.ReturnType == typeof(ValueTask))
+                else if (methodInfo.ReturnType == typeof(ValueTask))
                 {
                     body = Expression.Call(
                                         ExecuteValueTaskMethodInfo,
                                         methodCall);
                 }
-                else if (method.ReturnType.IsGenericType &&
-                         method.ReturnType.GetGenericTypeDefinition() == typeof(Task<>))
+                else if (methodInfo.ReturnType.IsGenericType &&
+                         methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Task<>))
                 {
-                    var typeArg = method.ReturnType.GetGenericArguments()[0];
+                    var typeArg = methodInfo.ReturnType.GetGenericArguments()[0];
 
                     if (typeof(IResult).IsAssignableFrom(typeArg))
                     {
@@ -227,10 +298,10 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
                         }
                     }
                 }
-                else if (method.ReturnType.IsGenericType &&
-                         method.ReturnType.GetGenericTypeDefinition() == typeof(ValueTask<>))
+                else if (methodInfo.ReturnType.IsGenericType &&
+                         methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(ValueTask<>))
                 {
-                    var typeArg = method.ReturnType.GetGenericArguments()[0];
+                    var typeArg = methodInfo.ReturnType.GetGenericArguments()[0];
 
                     if (typeof(IResult).IsAssignableFrom(typeArg))
                     {
@@ -261,18 +332,18 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
                 else
                 {
                     // TODO: Handle custom awaitables
-                    throw new NotSupportedException($"Unsupported return type: {method.ReturnType}");
+                    throw new NotSupportedException($"Unsupported return type: {methodInfo.ReturnType}");
                 }
             }
-            else if (typeof(IResult).IsAssignableFrom(method.ReturnType))
+            else if (typeof(IResult).IsAssignableFrom(methodInfo.ReturnType))
             {
                 body = Expression.Call(methodCall, ResultWriteResponseAsync, HttpContextParameter);
             }
-            else if (method.ReturnType == typeof(string))
+            else if (methodInfo.ReturnType == typeof(string))
             {
                 body = Expression.Call(StringResultWriteResponseAsync, HttpResponseExpr, methodCall, Expression.Constant(CancellationToken.None));
             }
-            else if (method.ReturnType.IsValueType)
+            else if (methodInfo.ReturnType.IsValueType)
             {
                 var box = Expression.TypeAs(methodCall, typeof(object));
                 body = Expression.Call(JsonResultWriteResponseAsync, HttpResponseExpr, box, Expression.Constant(CancellationToken.None));
@@ -364,10 +435,7 @@ public static RequestDelegate BuildRequestDelegate(Delegate action)
                 requestDelegate = invoker;
             }
 
-            return httpContext =>
-            {
-                return requestDelegate(action.Target, httpContext);
-            };
+            return requestDelegate;
         }
 
         private static ILogger GetLogger(HttpContext httpContext)
diff --git a/src/Http/Http.Extensions/test/RequestDelegateBuilderTests.cs b/src/Http/Http.Extensions/test/RequestDelegateBuilderTests.cs
@@ -7,6 +7,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using System.Reflection;
 using System.Text;
 using System.Text.Json;
 using System.Threading;
@@ -22,7 +23,7 @@
 
 namespace Microsoft.AspNetCore.Routing.Internal
 {
-    public class RouteDelegateBuilderTests
+    public class RequestDelegateBuilderTests
     {
         public static IEnumerable<object[]> NoResult
         {
@@ -92,6 +93,98 @@ public async Task RequestDelegateInvokesAction(Delegate @delegate)
             Assert.True(httpContext.Items["invoked"] as bool?);
         }
 
+        private static void StaticTestActionBasicReflection(HttpContext httpContext)
+        {
+            httpContext.Items.Add("invoked", true);
+        }
+
+        [Fact]
+        public async Task StaticMethodInfoOverloadWorksWithBasicReflection()
+        {
+            var methodInfo = typeof(RequestDelegateBuilderTests).GetMethod(
+                nameof(StaticTestActionBasicReflection),
+                BindingFlags.NonPublic | BindingFlags.Static,
+                new[] { typeof(HttpContext) });
+
+            var requestDelegate = RequestDelegateBuilder.BuildRequestDelegate(methodInfo!);
+
+            var httpContext = new DefaultHttpContext();
+
+            await requestDelegate(httpContext);
+
+            Assert.True(httpContext.Items["invoked"] as bool?);
+        }
+
+        private class TestNonStaticActionClass
+        {
+            private readonly object _invokedValue;
+
+            public TestNonStaticActionClass(object invokedValue)
+            {
+                _invokedValue = invokedValue;
+            }
+
+            private void NonStaticTestAction(HttpContext httpContext)
+            {
+                httpContext.Items.Add("invoked", _invokedValue);
+            }
+        }
+
+        [Fact]
+        public async Task NonStaticMethodInfoOverloadWorksWithBasicReflection()
+        {
+            var methodInfo = typeof(TestNonStaticActionClass).GetMethod(
+                "NonStaticTestAction",
+                BindingFlags.NonPublic | BindingFlags.Instance,
+                new[] { typeof(HttpContext) });
+
+            var invoked = false;
+
+            object GetTarget()
+            {
+                if (!invoked)
+                {
+                    invoked = true;
+                    return new TestNonStaticActionClass(1);
+                }
+
+                return new TestNonStaticActionClass(2);
+            }
+
+            var requestDelegate = RequestDelegateBuilder.BuildRequestDelegate(methodInfo!, _ => GetTarget());
+
+            var httpContext = new DefaultHttpContext();
+
+            await requestDelegate(httpContext);
+
+            Assert.Equal(1, httpContext.Items["invoked"]);
+
+            httpContext = new DefaultHttpContext();
+
+            await requestDelegate(httpContext);
+
+            Assert.Equal(2, httpContext.Items["invoked"]);
+        }
+
+        [Fact]
+        public void BuildRequestDelegateThrowsArgumentNullExceptions()
+        {
+            var methodInfo = typeof(RequestDelegateBuilderTests).GetMethod(
+                nameof(StaticTestActionBasicReflection),
+                BindingFlags.NonPublic | BindingFlags.Static,
+                new[] { typeof(HttpContext) });
+
+            var exNullAction = Assert.Throws<ArgumentNullException>(() => RequestDelegateBuilder.BuildRequestDelegate(action: null!));
+            var exNullMethodInfo1 = Assert.Throws<ArgumentNullException>(() => RequestDelegateBuilder.BuildRequestDelegate(methodInfo: null!));
+            var exNullMethodInfo2 = Assert.Throws<ArgumentNullException>(() => RequestDelegateBuilder.BuildRequestDelegate(methodInfo: null!, _ => 0));
+            var exNullTargetFactory = Assert.Throws<ArgumentNullException>(() => RequestDelegateBuilder.BuildRequestDelegate(methodInfo!, targetFactory: null!));
+
+            Assert.Equal("action", exNullAction.ParamName);
+            Assert.Equal("methodInfo", exNullMethodInfo1.ParamName);
+            Assert.Equal("methodInfo", exNullMethodInfo2.ParamName);
+            Assert.Equal("targetFactory", exNullTargetFactory.ParamName);
+        }
+
         public static IEnumerable<object[]> FromRouteResult
         {
             get
