fix(SimpleW.Helper.DependencyInjection): exception when delegate return Task/ValueTask with object (#382)

Author: stratdev3

src/SimpleW.Helper.DependencyInjection/DependencyInjectionRouteExecutorFactory.cs

@@ -282,7 +282,8 @@ private static ReturnAdapter CreateReturnAdapter(Type returnType) {
 
         private static ReturnAdapter CreateClosedReturnAdapter(MethodInfo openGenericMethod, Type resultType) {
             MethodInfo closedMethod = openGenericMethod.MakeGenericMethod(resultType);
-            return (ReturnAdapter)Delegate.CreateDelegate(typeof(ReturnAdapter), closedMethod);
+            Func<ReturnAdapter> factory = (Func<ReturnAdapter>)Delegate.CreateDelegate(typeof(Func<ReturnAdapter>), closedMethod);
+            return factory();
         }
 
         private static ReturnAdapter CreateTaskWithResultAdapter<T>() {

src/test/DependencyInjectionTests.cs

@@ -178,6 +178,62 @@ public async Task MapControllers_Should_Discover_Controllers_From_Base_Type_When
             }
         }
 
+        [Fact]
+        public async Task MapController_Should_Support_Task_With_Result_When_Di_Is_Enabled() {
+            int port = PortManager.GetFreePort();
+
+            await using ServiceProvider rootProvider = new ServiceCollection()
+                                                       .AddScoped<AsyncResultMessageService>(_ => new AsyncResultMessageService("task"))
+                                                       .BuildServiceProvider();
+
+            var server = new SimpleWServer(IPAddress.Loopback, port);
+            server.UseDependencyInjection(rootProvider);
+            server.MapController<TaskResultDiController>("/api");
+
+            try {
+                await server.StartAsync();
+
+                var client = new HttpClient();
+                var response = await client.GetAsync($"http://{server.Address}:{server.Port}/api/async-result/task");
+                var content = await response.Content.ReadAsStringAsync();
+
+                Check.That(response.StatusCode).Is(HttpStatusCode.OK);
+                Check.That(content).IsEqualTo(JsonSerializer.Serialize(new { message = "task" }));
+            }
+            finally {
+                await server.StopAsync();
+                PortManager.ReleasePort(port);
+            }
+        }
+
+        [Fact]
+        public async Task MapController_Should_Support_ValueTask_With_Result_When_Di_Is_Enabled() {
+            int port = PortManager.GetFreePort();
+
+            await using ServiceProvider rootProvider = new ServiceCollection()
+                                                       .AddScoped<AsyncResultMessageService>(_ => new AsyncResultMessageService("value-task"))
+                                                       .BuildServiceProvider();
+
+            var server = new SimpleWServer(IPAddress.Loopback, port);
+            server.UseDependencyInjection(rootProvider);
+            server.MapController<ValueTaskResultDiController>("/api");
+
+            try {
+                await server.StartAsync();
+
+                var client = new HttpClient();
+                var response = await client.GetAsync($"http://{server.Address}:{server.Port}/api/async-result/value-task");
+                var content = await response.Content.ReadAsStringAsync();
+
+                Check.That(response.StatusCode).Is(HttpStatusCode.OK);
+                Check.That(content).IsEqualTo(JsonSerializer.Serialize(new { message = "value-task" }));
+            }
+            finally {
+                await server.StopAsync();
+                PortManager.ReleasePort(port);
+            }
+        }
+
         [Fact]
         public async Task MapController_Should_Dispose_Controller_After_Request_When_Di_Is_Enabled() {
             int port = PortManager.GetFreePort();
@@ -364,6 +420,52 @@ public object Ping() {
 
         }
 
+        public sealed class AsyncResultMessageService {
+
+            public string Message { get; }
+
+            public AsyncResultMessageService(string message) {
+                Message = message;
+            }
+
+        }
+
+        [Route("/async-result")]
+        public sealed class TaskResultDiController : Controller {
+
+            private readonly AsyncResultMessageService _messageService;
+
+            public TaskResultDiController(AsyncResultMessageService messageService) {
+                _messageService = messageService;
+            }
+
+            [Route("GET", "/task")]
+            public Task<object> Get() {
+                return Task.FromResult<object>(new {
+                    message = _messageService.Message
+                });
+            }
+
+        }
+
+        [Route("/async-result")]
+        public sealed class ValueTaskResultDiController : Controller {
+
+            private readonly AsyncResultMessageService _messageService;
+
+            public ValueTaskResultDiController(AsyncResultMessageService messageService) {
+                _messageService = messageService;
+            }
+
+            [Route("GET", "/value-task")]
+            public ValueTask<object> Get() {
+                return ValueTask.FromResult<object>(new {
+                    message = _messageService.Message
+                });
+            }
+
+        }
+
         [Route("/dispose")]
         public sealed class DisposableDiController : Controller, IDisposable {