Introduce ActionResult<T>

Author: pranavkm

src/Microsoft.AspNetCore.Mvc.Core/ActionResultOfT.cs

@@ -0,0 +1,61 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+
+namespace Microsoft.AspNetCore.Mvc
+{
+    /// <summary>
+    /// A type that wraps either an <typeparamref name="TValue"/> instance or an <see cref="ActionResult"/>.
+    /// </summary>
+    /// <typeparam name="TValue">The type of the result.</typeparam>
+    public class ActionResult<TValue> : IConvertToActionResult
+    {
+        /// <summary>
+        /// Initializes a new instance of <see cref="ActionResult{TValue}"/> using the specified <paramref name="value"/>.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public ActionResult(TValue value)
+        {
+            Value = value;
+        }
+
+        /// <summary>
+        /// Intializes a new instance of <see cref="ActionResult{TValue}"/> using the specified <see cref="ActionResult"/>.
+        /// </summary>
+        /// <param name="result">The <see cref="ActionResult"/>.</param>
+        public ActionResult(ActionResult result)
+        {
+            Result = result ?? throw new ArgumentNullException(nameof(result));
+        }
+
+        /// <summary>
+        /// Gets the <see cref="ActionResult"/>.
+        /// </summary>
+        public ActionResult Result { get; }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        public TValue Value { get; }
+
+        public static implicit operator ActionResult<TValue>(TValue value)
+        {
+            return new ActionResult<TValue>(value);
+        }
+
+        public static implicit operator ActionResult<TValue>(ActionResult result)
+        {
+            return new ActionResult<TValue>(result);
+        }
+
+        IActionResult IConvertToActionResult.Convert()
+        {
+            return Result ?? new ObjectResult(Value)
+            {
+                DeclaredType = typeof(TValue),
+            };
+        }
+    }
+}

src/Microsoft.AspNetCore.Mvc.Core/Infrastructure/IConvertToActionResult.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.Mvc.Infrastructure
+{
+    /// <summary>
+    /// Defines the contract to convert a type to an <see cref="IActionResult"/> during action invocation.
+    /// </summary>
+    public interface IConvertToActionResult
+    {
+        /// <summary>
+        /// Converts the current instance to an instance of <see cref="IActionResult"/>.
+        /// </summary>
+        /// <returns>The converted <see cref="IActionResult"/>.</returns>
+        IActionResult Convert();
+    }
+}

src/Microsoft.AspNetCore.Mvc.Core/Internal/ControllerActionInvoker.cs

@@ -9,6 +9,7 @@
 using Microsoft.AspNetCore.Mvc.Abstractions;
 using Microsoft.AspNetCore.Mvc.Core;
 using Microsoft.AspNetCore.Mvc.Filters;
+using Microsoft.AspNetCore.Mvc.Infrastructure;
 using Microsoft.Extensions.Internal;
 using Microsoft.Extensions.Logging;
 
@@ -311,6 +312,7 @@ private async Task InvokeActionMethodAsync()
 
             var diagnosticSource = _diagnosticSource;
             var logger = _logger;
+            var returnType = executor.MethodReturnType;
 
             IActionResult result = null;
             try
@@ -321,7 +323,6 @@ private async Task InvokeActionMethodAsync()
                     controller);
                 logger.ActionMethodExecuting(controllerContext, orderedArguments);
 
-                var returnType = executor.MethodReturnType;
                 if (returnType == typeof(void))
                 {
                     // Sync method returning void
@@ -346,6 +347,30 @@ private async Task InvokeActionMethodAsync()
                             Resources.FormatActionResult_ActionReturnValueCannotBeNull(typeof(IActionResult)));
                     }
                 }
+                else if (IsConvertibleToActionResult(executor))
+                {
+                    IConvertToActionResult convertToActionResult;
+                    if (executor.IsMethodAsync)
+                    {
+                        // Async method returning awaitable-of-ActionResult<T> (e.g., Task<ActionResult<Person>>)
+                        // We have to use ExecuteAsync because we don't know the awaitable's type at compile time.
+                        convertToActionResult = (IConvertToActionResult)await executor.ExecuteAsync(controller, orderedArguments);
+                    }
+                    else
+                    {
+                        // Sync method returning ActionResult<T>
+                        convertToActionResult = (IConvertToActionResult)executor.Execute(controller, orderedArguments);
+                    }
+
+                    result = convertToActionResult.Convert();
+
+                    if (result == null)
+                    {
+                        throw new InvalidOperationException(
+                            Resources.FormatActionResult_ActionReturnValueCannotBeNull(typeof(IConvertToActionResult)));
+                    }
+
+                }
                 else if (IsResultIActionResult(executor))
                 {
                     if (executor.IsMethodAsync)
@@ -370,10 +395,8 @@ private async Task InvokeActionMethodAsync()
                 {
                     // Sync method returning arbitrary object
                     var resultAsObject = executor.Execute(controller, orderedArguments);
-                    result = resultAsObject as IActionResult ?? new ObjectResult(resultAsObject)
-                    {
-                        DeclaredType = returnType,
-                    };
+                    ConvertToActionResult(resultAsObject);
+
                 }
                 else if (executor.AsyncResultType == typeof(void))
                 {
@@ -385,10 +408,7 @@ private async Task InvokeActionMethodAsync()
                 {
                     // Async method returning awaitable-of-nonvoid
                     var resultAsObject = await executor.ExecuteAsync(controller, orderedArguments);
-                    result = resultAsObject as IActionResult ?? new ObjectResult(resultAsObject)
-                    {
-                        DeclaredType = executor.AsyncResultType,
-                    };
+                    ConvertToActionResult(resultAsObject);
                 }
 
                 _result = result;
@@ -402,6 +422,25 @@ private async Task InvokeActionMethodAsync()
                     controllerContext,
                     result);
             }
+
+            void ConvertToActionResult(object resultAsObject)
+            {
+                if (resultAsObject is IActionResult actionResult)
+                {
+                    result = actionResult;
+                }
+                else if (resultAsObject is IConvertToActionResult convertToActionResult)
+                {
+                    result = convertToActionResult.Convert();
+                }
+                else
+                {
+                    result = new ObjectResult(resultAsObject)
+                    {
+                        DeclaredType = returnType,
+                    };
+                }
+            }
         }
 
         private static bool IsResultIActionResult(ObjectMethodExecutor executor)
@@ -410,6 +449,12 @@ private static bool IsResultIActionResult(ObjectMethodExecutor executor)
             return typeof(IActionResult).IsAssignableFrom(resultType);
         }
 
+        private bool IsConvertibleToActionResult(ObjectMethodExecutor executor)
+        {
+            var resultType = executor.AsyncResultType ?? executor.MethodReturnType;
+            return typeof(IConvertToActionResult).IsAssignableFrom(resultType);
+        }
+
         /// <remarks><see cref="ResourceInvoker.InvokeFilterPipelineAsync"/> for details on what the
         /// variables in this method represent.</remarks>
         protected override async Task InvokeInnerFilterAsync()

test/Microsoft.AspNetCore.Mvc.Core.Test/ActionResultOfTTest.cs

@@ -0,0 +1,68 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Mvc.Infrastructure;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Mvc
+{
+    public class ActionResultOfTTest
+    {
+        [Fact]
+        public void Convert_ReturnsResultIfSet()
+        {
+            // Arrange
+            var expected = new OkResult();
+            var actionResultOfT = new ActionResult<string>(expected);
+            var convertToActionResult = (IConvertToActionResult)actionResultOfT;
+
+            // Act
+            var result = convertToActionResult.Convert();
+
+            // Assert
+            Assert.Same(expected, result);
+        }
+
+        [Fact]
+        public void Convert_ReturnsObjectResultWrappingValue()
+        {
+            // Arrange
+            var value = new BaseItem();
+            var actionResultOfT = new ActionResult<BaseItem>(value);
+            var convertToActionResult = (IConvertToActionResult)actionResultOfT;
+
+            // Act
+            var result = convertToActionResult.Convert();
+
+            // Assert
+            var objectResult = Assert.IsType<ObjectResult>(result);
+            Assert.Same(value, objectResult.Value);
+            Assert.Equal(typeof(BaseItem), objectResult.DeclaredType);
+        }
+
+        [Fact]
+        public void Convert_InfersDeclaredTypeFromActionResultTypeParameter()
+        {
+            // Arrange
+            var value = new DeriviedItem();
+            var actionResultOfT = new ActionResult<BaseItem>(value);
+            var convertToActionResult = (IConvertToActionResult)actionResultOfT;
+
+            // Act
+            var result = convertToActionResult.Convert();
+
+            // Assert
+            var objectResult = Assert.IsType<ObjectResult>(result);
+            Assert.Same(value, objectResult.Value);
+            Assert.Equal(typeof(BaseItem), objectResult.DeclaredType);
+        }
+
+        private class BaseItem
+        {
+        }
+
+        private class DeriviedItem : BaseItem
+        {
+        }
+    }
+}