Trim Async suffix on action names

Fixes #4849

Author: pranavkm

src/Mvc/samples/MvcSandbox/Controllers/HomeController.cs

@@ -10,7 +10,7 @@ public class HomeController : Controller
         [ModelBinder]
         public string Id { get; set; }
 
-        public IActionResult Index()
+        public IActionResult IndexAsync()
         {
             return View();
         }

src/Mvc/src/Microsoft.AspNetCore.Mvc.Core/ApplicationModels/DefaultApplicationModelProvider.cs

@@ -22,6 +22,7 @@ internal class DefaultApplicationModelProvider : IApplicationModelProvider
         private readonly IModelMetadataProvider _modelMetadataProvider;
         private readonly Func<ActionContext, bool> _supportsAllRequests;
         private readonly Func<ActionContext, bool> _supportsNonGetRequests;
+        private readonly List<IActionModelConvention> _actionModelConventions;
 
         public DefaultApplicationModelProvider(
             IOptions<MvcOptions> mvcOptionsAccessor,
@@ -32,6 +33,12 @@ public DefaultApplicationModelProvider(
 
             _supportsAllRequests = _ => true;
             _supportsNonGetRequests = context => !string.Equals(context.HttpContext.Request.Method, "GET", StringComparison.OrdinalIgnoreCase);
+
+            _actionModelConventions = new List<IActionModelConvention>();
+            if (_mvcOptions.SuppressAsyncSuffixInActionNames)
+            {
+                _actionModelConventions.Add(new SuppressAsyncSuffixInActionNameConvention());
+            }
         }
 
         /// <inheritdoc />
@@ -92,6 +99,11 @@ public void OnProvidersExecuting(ApplicationModelProviderContext context)
                             actionModel.Parameters.Add(parameterModel);
                         }
                     }
+
+                    foreach (var convention in _actionModelConventions)
+                    {
+                        convention.Apply(actionModel);
+                    }
                 }
             }
         }

src/Mvc/src/Microsoft.AspNetCore.Mvc.Core/ApplicationModels/SuppressAsyncSuffixInActionNameConvention.cs

@@ -0,0 +1,44 @@
+// 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;
+
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    /// <summary>
+    /// <see cref="IActionModelConvention"/> that modifies <see cref="ActionModel.ActionName"/>
+    /// to remove the Async suffix. <see cref="ActionModel.ActionName"/> is used to construct the
+    /// route to the action, as well as view lookup.
+    /// </summary>
+    public class SuppressAsyncSuffixInActionNameConvention : IActionModelConvention
+    {
+        /// <summary>
+        /// Determines if the convention applies to specified <paramref name="action"/>.
+        /// Defaults to returning <see langword="true"/>.
+        /// </summary>
+        /// <param name="action">The <see cref="ActionModel"/>.</param>
+        /// <returns><see langword="true"/> if the convention should apply to <paramref name="action"/>.</returns>
+        protected virtual bool ShouldApply(ActionModel action) => true;
+
+        /// <inheritdoc />
+        public void Apply(ActionModel action)
+        {
+            if (action == null)
+            {
+                throw new ArgumentNullException(nameof(action));
+            }
+
+            if (!ShouldApply(action))
+            {
+                return;
+            }
+
+            const string Suffix = "Async";
+
+            if (action.ActionName.EndsWith(Suffix, StringComparison.Ordinal))
+            {
+                action.ActionName = action.ActionName.Substring(0, action.ActionName.Length - Suffix.Length);
+            }
+        }
+    }
+}

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

@@ -209,6 +209,21 @@ public int? MaxValidationDepth
             }
         }
 
+        /// <summary>
+        /// Gets or sets a value that determines if MVC will ignore the suffix "Async" applied to
+        /// controller action names.
+        /// <para>
+        /// When <see langword="true"/>, MVC will strip action names of the Async suffix.
+        /// Action names are used for routing as well as view lookup. For example, the action
+        /// action <c>ProductsController.ListProductsAsync</c> will be routeable at <c>/Products/ListProducts</c>
+        /// with views looked up at <c>/Views/Products/ListProducts.cshtml</c>.
+        /// </para>
+        /// </summary>
+        /// <value>
+        /// The default value is <c>true</c>.
+        /// </value>
+        public bool SuppressAsyncSuffixInActionNames { get; set; } = true;
+
         IEnumerator<ICompatibilitySwitch> IEnumerable<ICompatibilitySwitch>.GetEnumerator() => _switches.GetEnumerator();
 
         IEnumerator IEnumerable.GetEnumerator() => _switches.GetEnumerator();

src/Mvc/test/Microsoft.AspNetCore.Mvc.Core.Test/ApplicationModels/DefaultApplicationModelProviderTest.cs

@@ -293,6 +293,44 @@ public void OnProvidersExecuting_UsesBindingSourceSpecifiedOnParameter()
                 });
         }
 
+        [Fact]
+        public void OnProvidersExecuting_RemovesAsyncSuffix_WhenOptionIsSet()
+        {
+            // Arrange
+            var options = new MvcOptions();
+            var provider = new TestApplicationModelProvider(options, new EmptyModelMetadataProvider());
+            var typeInfo = typeof(AsyncActionController).GetTypeInfo();
+
+            var context = new ApplicationModelProviderContext(new[] { typeInfo });
+
+            // Act
+            provider.OnProvidersExecuting(context);
+
+            // Assert
+            var controllerModel = Assert.Single(context.Result.Controllers);
+            var action = Assert.Single(controllerModel.Actions);
+            Assert.Equal("GetPerson", action.ActionName);
+        }
+
+        [Fact]
+        public void OnProvidersExecuting_DoesNotRemoveAsyncSuffix_WhenOptionIsDisabled()
+        {
+            // Arrange
+            var options = new MvcOptions { SuppressAsyncSuffixInActionNames = false };
+            var provider = new TestApplicationModelProvider(options, new EmptyModelMetadataProvider());
+            var typeInfo = typeof(AsyncActionController).GetTypeInfo();
+
+            var context = new ApplicationModelProviderContext(new[] { typeInfo });
+
+            // Act
+            provider.OnProvidersExecuting(context);
+
+            // Assert
+            var controllerModel = Assert.Single(context.Result.Controllers);
+            var action = Assert.Single(controllerModel.Actions);
+            Assert.Equal(nameof(AsyncActionController.GetPersonAsync), action.ActionName);
+        }
+
         [Fact]
         public void CreateControllerModel_DerivedFromControllerClass_HasFilter()
         {
@@ -1774,6 +1812,11 @@ private class MultipleRouteProviderOnActionController
             public void Edit() { }
         }
 
+        private class AsyncActionController : Controller
+        {
+            public IActionResult GetPersonAsync() => null;
+        }
+
         private class TestApplicationModelProvider : DefaultApplicationModelProvider
         {
             public TestApplicationModelProvider()

src/Mvc/test/Microsoft.AspNetCore.Mvc.Core.Test/ApplicationModels/SuppressAsyncSuffixInActionNameConventionTest.cs

@@ -0,0 +1,60 @@
+// 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 Xunit;
+
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    public class SuppressAsyncSuffixInActionNameConventionTest
+    {
+        private readonly ActionModel ActionModel = new ActionModel(typeof(object).GetMethod(nameof(string.ToString)), Array.Empty<object>());
+
+        [Fact]
+        public void Apply_RemovesSuffix()
+        {
+            // Arrange
+            ActionModel.ActionName = "ListItemsAsync";
+            var convention = new SuppressAsyncSuffixInActionNameConvention();
+
+            // Act
+            convention.Apply(ActionModel);
+
+            // Assert
+            Assert.Equal("ListItems", ActionModel.ActionName);
+        }
+
+        [Fact]
+        public void Apply_NoOpsIfNameDoesNotEndWithSuffix()
+        {
+            // Arrange
+            ActionModel.ActionName = "ListItems";
+            var convention = new SuppressAsyncSuffixInActionNameConvention();
+
+            // Act
+            convention.Apply(ActionModel);
+
+            // Assert
+            Assert.Equal("ListItems", ActionModel.ActionName);
+        }
+
+        [Fact]
+        public void Apply_NoOpsIfShouldApplyReturnsFalse()
+        {
+            // Arrange
+            ActionModel.ActionName = "ListItemsAsync";
+            var convention = new TestSuppressAsyncSuffixInActionNameConvention();
+
+            // Act
+            convention.Apply(ActionModel);
+
+            // Assert
+            Assert.Equal("ListItemsAsync", ActionModel.ActionName);
+        }
+
+        private class TestSuppressAsyncSuffixInActionNameConvention : SuppressAsyncSuffixInActionNameConvention
+        {
+            protected override bool ShouldApply(ActionModel action) => false;
+        }
+    }
+}

src/Mvc/test/Microsoft.AspNetCore.Mvc.FunctionalTests/AsyncActionsTests.cs

@@ -278,5 +278,37 @@ public async Task CustomAwaitableOfContentResultExceptionAction_ReturnsCorrectEr
             // Assert
             Assert.Equal("Action exception message: This is a custom exception.", responseBody);
         }
+
+        [Fact]
+        public async Task AsyncSuffixIsIgnored()
+        {
+            // Act
+            var response = await Client.GetAsync("AsyncActions/ActionWithSuffix");
+
+            // Assert
+            await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+        }
+
+        [Fact]
+        public async Task ActionCannotBeRoutedWithAsyncSuffix()
+        {
+            // Act
+            var response = await Client.GetAsync("AsyncActions/ActionWithSuffixAsync");
+
+            // Assert
+            await response.AssertStatusCodeAsync(HttpStatusCode.NotFound);
+        }
+
+        [Fact]
+        public async Task ViewLookupWithAsyncSuffix()
+        {
+            // Act
+            var response = await Client.GetAsync("AsyncActions/ActionReturningView");
+
+            // Assert
+            await response.AssertStatusCodeAsync(HttpStatusCode.OK);
+            var content = await response.Content.ReadAsStringAsync();
+            Assert.Equal("Hello world!", content.Trim());
+        }
     }
 }

src/Mvc/test/WebSites/BasicWebSite/Controllers/AsyncActionsController.cs

@@ -26,6 +26,17 @@ public override void OnActionExecuted(ActionExecutedContext context)
             }
         }
 
+        public async Task<IActionResult> ActionWithSuffixAsync()
+        {
+            await Task.Yield();
+            return Ok();
+        }
+
+        public IActionResult ActionReturningViewAsync()
+        {
+            return View();
+        }
+
         public async void AsyncVoidAction()
         {
             await Task.Delay(SimulateDelayMilliseconds);

src/Mvc/test/WebSites/BasicWebSite/Views/AsyncActions/ActionReturningView.cshtml

@@ -0,0 +1 @@
+Hello world!