Add enhanced support filtering API controllers

Author: Chris Martinez

src/Microsoft.AspNetCore.Mvc.Versioning/ApplicationModels/ApiBehaviorSpecification.cs

@@ -0,0 +1,34 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using System;
+    using System.Linq;
+    using System.Reflection;
+
+    /// <summary>
+    /// Represents a specification that matches API controllers by the presence of API behaviors.
+    /// </summary>
+    [CLSCompliant( false )]
+    public sealed class ApiBehaviorSpecification : IApiControllerSpecification
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApiBehaviorSpecification"/> class.
+        /// </summary>
+        public ApiBehaviorSpecification()
+        {
+            const string ApiBehaviorApplicationModelProviderTypeName = "Microsoft.AspNetCore.Mvc.ApplicationModels.ApiBehaviorApplicationModelProvider, Microsoft.AspNetCore.Mvc.Core";
+            var type = Type.GetType( ApiBehaviorApplicationModelProviderTypeName, throwOnError: true );
+            var method = type.GetRuntimeMethods().Single( m => m.Name == "IsApiController" );
+
+            IsApiController = (Func<ControllerModel, bool>) method.CreateDelegate( typeof( Func<ControllerModel, bool> ) );
+        }
+
+        Func<ControllerModel, bool> IsApiController { get; }
+
+        /// <inheritdoc />
+        public bool IsSatisfiedBy( ControllerModel controller )
+        {
+            Arg.NotNull( controller, nameof( controller ) );
+            return IsApiController( controller );
+        }
+    }
+}

src/Microsoft.AspNetCore.Mvc.Versioning/ApplicationModels/DefaultApiControllerFilter.cs

@@ -0,0 +1,67 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.Contracts;
+    using System.Linq;
+
+    /// <summary>
+    /// Represents the default API controller filter.
+    /// </summary>
+    [CLSCompliant( false )]
+    public sealed class DefaultApiControllerFilter : IApiControllerFilter
+    {
+        readonly IReadOnlyList<IApiControllerSpecification> specifications;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DefaultApiControllerFilter"/> class.
+        /// </summary>
+        /// <param name="specifications">The <see cref="IEnumerable{T}">sequence</see> of
+        /// <see cref="IApiControllerSpecification">specifications</see> used by the filter
+        /// to identify API controllers.</param>
+        public DefaultApiControllerFilter( IEnumerable<IApiControllerSpecification> specifications )
+        {
+            Arg.NotNull( specifications, nameof( specifications ) );
+            this.specifications = specifications.ToArray();
+        }
+
+        /// <inheritdoc />
+        public IList<ControllerModel> Apply( IList<ControllerModel> controllers )
+        {
+            Arg.NotNull( controllers, nameof( controllers ) );
+            Contract.Ensures( Contract.Result<IList<ControllerModel>>() != null );
+
+            if ( specifications.Count == 0 )
+            {
+                return controllers;
+            }
+
+            var filtered = controllers.ToList();
+
+            for ( var i = filtered.Count - 1; i >= 0; i-- )
+            {
+                if ( !IsApiController( filtered[i] ) )
+                {
+                    filtered.RemoveAt( i );
+                }
+            }
+
+            return filtered;
+        }
+
+        bool IsApiController( ControllerModel controller )
+        {
+            Contract.Requires( controller != null );
+
+            for ( var i = 0; i < specifications.Count; i++ )
+            {
+                if ( specifications[i].IsSatisfiedBy( controller ) )
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

src/Microsoft.AspNetCore.Mvc.Versioning/ApplicationModels/IApiControllerFilter.cs

@@ -0,0 +1,21 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using System;
+    using System.Collections.Generic;
+
+    /// <summary>
+    /// Defines the behavior of an API controller filter.
+    /// </summary>
+    [CLSCompliant( false )]
+    public interface IApiControllerFilter
+    {
+        /// <summary>
+        /// Applies the filter to the provided list of controllers.
+        /// </summary>
+        /// <param name="controllers">The <see cref="IList{T}">list</see> of
+        /// <see cref="ControllerModel">controllers</see> to filter.</param>
+        /// <returns>A new, filtered <see cref="IList{T}">list</see> of API
+        /// <see cref="ControllerModel">controllers</see>.</returns>
+        IList<ControllerModel> Apply( IList<ControllerModel> controllers );
+    }
+}

src/Microsoft.AspNetCore.Mvc.Versioning/ApplicationModels/IApiControllerSpecification.cs

@@ -0,0 +1,18 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using System;
+
+    /// <summary>
+    /// Defines the behavior of an API controller specification.
+    /// </summary>
+    [CLSCompliant( false )]
+    public interface IApiControllerSpecification
+    {
+        /// <summary>
+        /// Determines whether the specification is satisified by the provided controller model.
+        /// </summary>
+        /// <param name="controller">The <see cref="ControllerModel">controller model</see> to evaluate.</param>
+        /// <returns>True if the <paramref name="controller"/> satisifies the specification; otherwise, false.</returns>
+        bool IsSatisfiedBy( ControllerModel controller );
+    }
+}

src/Microsoft.AspNetCore.Mvc.Versioning/Versioning/ApiVersioningApplicationModelProvider.cs

@@ -4,10 +4,7 @@
     using Microsoft.AspNetCore.Mvc.Versioning.Conventions;
     using Microsoft.Extensions.Options;
     using System;
-    using System.Collections.Generic;
     using System.Diagnostics.Contracts;
-    using System.Linq;
-    using System.Reflection;
 
     /// <summary>
     /// Represents an <see cref="IApplicationModelProvider">application model provider</see>, which
@@ -17,16 +14,19 @@
     public class ApiVersioningApplicationModelProvider : IApplicationModelProvider
     {
         readonly IOptions<ApiVersioningOptions> options;
-        readonly Lazy<Func<ControllerModel, bool>> isApiController = new Lazy<Func<ControllerModel, bool>>( NewIsApiControllerFunc );
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ApiVersioningApplicationModelProvider"/> class.
         /// </summary>
         /// <param name="options">The current <see cref="ApiVersioningOptions">API versioning options</see>.</param>
-        public ApiVersioningApplicationModelProvider( IOptions<ApiVersioningOptions> options )
+        /// <param name="controllerFilter">The <see cref="IApiControllerFilter">filter</see> used for API controllers.</param>
+        public ApiVersioningApplicationModelProvider( IOptions<ApiVersioningOptions> options, IApiControllerFilter controllerFilter )
         {
             Arg.NotNull( options, nameof( options ) );
+            Arg.NotNull( controllerFilter, nameof( controllerFilter ) );
+
             this.options = options;
+            ControllerFilter = controllerFilter;
         }
 
         /// <summary>
@@ -35,6 +35,12 @@ public ApiVersioningApplicationModelProvider( IOptions<ApiVersioningOptions> opt
         /// <value>The current <see cref="ApiVersioningOptions">API versioning options</see>.</value>
         protected ApiVersioningOptions Options => options.Value;
 
+        /// <summary>
+        /// Gets the filter used for API controllers.
+        /// </summary>
+        /// <value>The <see cref="IApiControllerFilter"/> used to filter API controllers.</value>
+        protected IApiControllerFilter ControllerFilter { get; }
+
         /// <inheritdoc />
         public int Order { get; protected set; }
 
@@ -46,11 +52,11 @@ public virtual void OnProvidersExecuted( ApplicationModelProviderContext context
             var implicitVersionModel = new ApiVersionModel( Options.DefaultApiVersion );
             var conventionBuilder = Options.Conventions;
             var application = context.Result;
-            IEnumerable<ControllerModel> controllers = application.Controllers;
+            var controllers = application.Controllers;
 
             if ( Options.UseApiBehavior )
             {
-                controllers = controllers.Where( isApiController.Value );
+                controllers = ControllerFilter.Apply( controllers );
             }
 
             foreach ( var controller in controllers )
@@ -106,12 +112,5 @@ static void ApplyAttributeOrImplicitConventions( ControllerModel controller, Api
                 ApplyImplicitConventions( controller, implicitVersionModel );
             }
         }
-
-        static Func<ControllerModel, bool> NewIsApiControllerFunc()
-        {
-            var type = Type.GetType( "Microsoft.AspNetCore.Mvc.ApplicationModels.ApiBehaviorApplicationModelProvider, Microsoft.AspNetCore.Mvc.Core", throwOnError: true );
-            var method = type.GetRuntimeMethods().Single( m => m.Name == "IsApiController" );
-            return (Func<ControllerModel, bool>) method.CreateDelegate( typeof( Func<ControllerModel, bool> ) );
-        }
     }
 }

src/Microsoft.AspNetCore.Mvc.Versioning/Versioning/ApiVersioningOptions.cs

@@ -1,6 +1,7 @@
 namespace Microsoft.AspNetCore.Mvc.Versioning
 {
     using Microsoft.AspNetCore.Builder;
+    using Microsoft.AspNetCore.Mvc.ApplicationModels;
 
     /// <content>
     /// Provides additional implementation specific to ASP.NET Core.
@@ -22,9 +23,10 @@ public partial class ApiVersioningOptions
         /// Gets or sets a value indicating whether to use web API behaviors.
         /// </summary>
         /// <value>True to use web API behaviors; otherwise, false. The default value is <c>true</c>.</value>
-        /// <remarks>When this property is set to <c>true</c>, API versioning policies only apply to controllers that
-        /// have the ApiControllerAttribute applied. When this property is set to <c>false</c>, API versioning
-        /// policies are considers for all controllers. This was default behavior prior to ASP.NET Core 2.2.</remarks>
+        /// <remarks>When this property is set to <c>true</c>, API versioning policies only apply to controllers
+        /// that remain after the <see cref="IApiControllerFilter"/> has been applied. When this property is set
+        /// to <c>false</c>, API versioning policies are considers for all controllers. This was default behavior
+        /// behavior in previous versions.</remarks>
         public bool UseApiBehavior { get; set; } = true;
     }
 }

src/Microsoft.AspNetCore.OData.Versioning/AspNetCore.Mvc/ApplicationModels/ODataControllerSpecification.cs

@@ -0,0 +1,19 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using Microsoft.AspNet.OData;
+    using System;
+
+    /// <summary>
+    /// Represents a specification that matches API controllers if they use the OData protocol.
+    /// </summary>
+    [CLSCompliant( false )]
+    public sealed class ODataControllerSpecification : IApiControllerSpecification
+    {
+        /// <inheritdoc />
+        public bool IsSatisfiedBy( ControllerModel controller )
+        {
+            Arg.NotNull( controller, nameof( controller ) );
+            return controller.ControllerType.IsODataController();
+        }
+    }
+}

src/Microsoft.AspNetCore.OData.Versioning/Extensions.DependencyInjection/IODataBuilderExtensions.cs

@@ -72,6 +72,7 @@ static void AddODataServices( IServiceCollection services )
             services.AddTransient<IApplicationModelProvider, ODataApplicationModelProvider>();
             services.AddTransient<IActionDescriptorProvider, ODataActionDescriptorProvider>();
             services.AddSingleton<IActionDescriptorChangeProvider>( ODataActionDescriptorChangeProvider.Instance );
+            services.TryAddEnumerable( Transient<IApiControllerSpecification, ODataControllerSpecification>() );
             services.AddModelConfigurationsAsServices( partManager );
         }
 

test/Microsoft.AspNetCore.Mvc.Versioning.Tests/ApplicationModels/ApiBehaviorSpecificationTest.cs

@@ -0,0 +1,42 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using FluentAssertions;
+    using System;
+    using System.Reflection;
+    using Xunit;
+
+    public class ApiBehaviorSpecificationTest
+    {
+        [Theory]
+        [InlineData( typeof( ApiBehaviorController ), true )]
+        [InlineData( typeof( NonApiBehaviorController ), false )]
+        public void is_satisfied_by_should_return_expected_result( Type controllerType, bool expected )
+        {
+            // arrange
+            var specification = new ApiBehaviorSpecification();
+            var attributes = controllerType.GetCustomAttributes( inherit: false );
+            var controller = new ControllerModel( controllerType.GetTypeInfo(), attributes );
+
+            // act
+            var result = specification.IsSatisfiedBy( controller );
+
+            // assert
+            result.Should().Be( expected );
+        }
+
+        [ApiController]
+        [Route( "api/test" )]
+        sealed class ApiBehaviorController : ControllerBase
+        {
+            [HttpGet]
+            public IActionResult Get() => Ok();
+        }
+
+        [Route( "/" )]
+        sealed class NonApiBehaviorController : Controller
+        {
+            [HttpGet]
+            public IActionResult Index() => View();
+        }
+    }
+}

test/Microsoft.AspNetCore.Mvc.Versioning.Tests/ApplicationModels/DefaultApiControllerFilterTest.cs

@@ -0,0 +1,61 @@
+namespace Microsoft.AspNetCore.Mvc.ApplicationModels
+{
+    using FluentAssertions;
+    using Moq;
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Xunit;
+
+    public class DefaultApiControllerFilterTest
+    {
+        [Fact]
+        public void apply_should_not_filter_list_without_specifications()
+        {
+            // arrange
+            var filter = new DefaultApiControllerFilter( Enumerable.Empty<IApiControllerSpecification>() );
+            var controllerType = typeof( ControllerBase ).GetTypeInfo();
+            var attributes = Array.Empty<object>();
+            var controllers = new List<ControllerModel>()
+            {
+                new ControllerModel( controllerType, attributes ),
+                new ControllerModel( controllerType, attributes ),
+                new ControllerModel( controllerType, attributes ),
+            };
+
+            // act
+            var result = filter.Apply( controllers );
+
+            // assert
+            result.Should().BeSameAs( controllers );
+        }
+
+        [Fact]
+        public void apply_should_filter_controllers()
+        {
+            // arrange
+            var specification = new Mock<IApiControllerSpecification>();
+            var controllerBaseType = typeof( ControllerBase ).GetTypeInfo();
+            var controllerType = typeof( Controller ).GetTypeInfo();
+
+            specification.Setup( s => s.IsSatisfiedBy( It.Is<ControllerModel>( m => m.ControllerType.Equals( controllerBaseType ) ) ) ).Returns( true );
+            specification.Setup( s => s.IsSatisfiedBy( It.Is<ControllerModel>( m => m.ControllerType.Equals( controllerType ) ) ) ).Returns( false );
+
+            var filter = new DefaultApiControllerFilter( new[] { specification.Object } );
+            var attributes = Array.Empty<object>();
+            var controllers = new List<ControllerModel>()
+            {
+                new ControllerModel( controllerType, attributes ),
+                new ControllerModel( controllerBaseType, attributes ),
+                new ControllerModel( controllerType, attributes ),
+            };
+
+            // act
+            var result = filter.Apply( controllers );
+
+            // assert
+            result.Single().Should().BeSameAs( controllers[1] );
+        }
+    }
+}