Refactor API versioning properties to a feature. Closes #280.

Author: Chris Martinez

src/Microsoft.AspNetCore.Mvc.Versioning/Builder/IApplicationBuilderExtensions.cs

@@ -0,0 +1,34 @@
+namespace Microsoft.AspNetCore.Builder
+{
+    using Microsoft.AspNetCore.Mvc.Versioning;
+    using System;
+
+    /// <summary>
+    /// Provides extension methods for the <see cref="IApplicationBuilder"/> interface.
+    /// </summary>
+    [CLSCompliant( false )]
+    public static class IApplicationBuilderExtensions
+    {
+        /// <summary>
+        /// Uses the API versioning middleware.
+        /// </summary>
+        /// <param name="app">The <see cref="IApplicationBuilder">application</see> to configure.</param>
+        /// <returns>The original <see cref="IApplicationBuilder"/>.</returns>
+        /// <remarks>
+        /// <para>
+        /// Configuration of the API versioning middleware is not necessary unless you explicitly
+        /// want to control when the middleware is added in the pipline. API versioning automatically configures
+        /// the required middleware, which is usually early enough for dependent middleware.
+        /// </para>
+        /// <para>
+        /// In addition to invoking <see cref="UseApiVersioning(IApplicationBuilder)"/>, you must also set
+        /// <see cref="ApiVersioningOptions.RegisterMiddleware"/> to <c>false</c>.
+        /// </para>
+        /// </remarks>
+        public static IApplicationBuilder UseApiVersioning( this IApplicationBuilder app )
+        {
+            Arg.NotNull( app, nameof( app ) );
+            return app.UseMiddleware<ApiVersioningMiddleware>();
+        }
+    }
+}

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

@@ -43,7 +43,9 @@ public static ApiVersionRequestProperties ApiVersionProperties( this HttpContext
         public static ApiVersion GetRequestedApiVersion( this HttpContext context )
         {
             Arg.NotNull( context, nameof( context ) );
-            return context.ApiVersionProperties().ApiVersion;
+
+            var feature = context.Features.Get<IApiVersioningFeature>();
+            return feature?.RequestedApiVersion;
         }
     }
 }

src/Microsoft.AspNetCore.Mvc.Versioning/Microsoft.Extensions.DependencyInjection/IServiceCollectionExtensions.cs

@@ -46,12 +46,16 @@ public static IServiceCollection AddApiVersioning( this IServiceCollection servi
             services.Add( new ServiceDescriptor( typeof( IErrorResponseProvider ), options.ErrorResponses ) );
             services.Add( Singleton<IOptions<ApiVersioningOptions>>( new OptionsWrapper<ApiVersioningOptions>( options ) ) );
             services.Replace( Singleton<IActionSelector, ApiVersionActionSelector>() );
-            services.TryAddSingleton<IApiVersionRoutePolicy, DefaultApiVersionRoutePolicy>();
             services.TryAddSingleton<ReportApiVersionsAttribute>();
-            services.AddTransient<IStartupFilter, InjectApiVersionRoutePolicy>();
+            services.AddTransient<IStartupFilter, AutoRegisterMiddleware>();
             services.AddMvcCore( mvcOptions => AddMvcOptions( mvcOptions, options ) );
             services.AddRouting( routeOptions => routeOptions.ConstraintMap.Add( options.RouteConstraintName, typeof( ApiVersionRouteConstraint ) ) );
 
+            if ( options.RegisterMiddleware )
+            {
+                services.TryAddSingleton<IApiVersionRoutePolicy, DefaultApiVersionRoutePolicy>();
+            }
+
             if ( options.ReportApiVersions )
             {
                 services.TryAddSingleton<IReportApiVersions, DefaultApiVersionReporter>();
@@ -78,20 +82,21 @@ static void AddMvcOptions( MvcOptions mvcOptions, ApiVersioningOptions options )
             mvcOptions.Conventions.Add( new ApiVersionConvention( options.DefaultApiVersion, options.Conventions ) );
         }
 
-        sealed class InjectApiVersionRoutePolicy : IStartupFilter
+        sealed class AutoRegisterMiddleware : IStartupFilter
         {
             readonly IApiVersionRoutePolicy routePolicy;
 
-            public InjectApiVersionRoutePolicy( IApiVersionRoutePolicy routePolicy ) => this.routePolicy = routePolicy;
+            public AutoRegisterMiddleware( IApiVersionRoutePolicy routePolicy ) => this.routePolicy = routePolicy;
 
-            public Action<IApplicationBuilder> Configure( Action<IApplicationBuilder> next )
+            public Action<IApplicationBuilder> Configure( Action<IApplicationBuilder> configure )
             {
-                Contract.Requires( next != null );
+                Contract.Requires( configure != null );
                 Contract.Ensures( Contract.Result<Action<IApplicationBuilder>>() != null );
 
                 return app =>
                 {
-                    next( app );
+                    app.UseApiVersioning();
+                    configure( app );
                     app.UseRouter( builder => builder.Routes.Add( routePolicy ) );
                 };
             }

src/Microsoft.AspNetCore.Mvc.Versioning/Routing/ApiVersionRouteConstraint.cs

@@ -1,7 +1,8 @@
 namespace Microsoft.AspNetCore.Mvc.Routing
 {
-    using AspNetCore.Routing;
-    using Http;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.AspNetCore.Mvc.Versioning;
+    using Microsoft.AspNetCore.Routing;
     using System;
     using static ApiVersion;
     using static AspNetCore.Routing.RouteDirection;
@@ -29,11 +30,11 @@ public bool Match( HttpContext httpContext, IRouter route, string routeKey, Rout
                 return false;
             }
 
-            var properties = httpContext.ApiVersionProperties();
+            var feature = httpContext.Features.Get<IApiVersioningFeature>();
 
             if ( values.TryGetValue( routeKey, out string value ) )
             {
-                properties.RawApiVersion = value;
+                feature.RawRequestedApiVersion = value;
             }
             else
             {
@@ -47,7 +48,7 @@ public bool Match( HttpContext httpContext, IRouter route, string routeKey, Rout
 
             if ( TryParse( value, out var requestedVersion ) )
             {
-                properties.ApiVersion = requestedVersion;
+                feature.RequestedApiVersion = requestedVersion;
                 return true;
             }
 

src/Microsoft.AspNetCore.Mvc.Versioning/Routing/DefaultApiVersionRoutePolicy.cs

@@ -258,11 +258,11 @@ RequestHandler ClientError( HttpContext httpContext, ActionSelectionResult selec
                 return NotFound;
             }
 
-            var properties = httpContext.ApiVersionProperties();
+            var feature = httpContext.Features.Get<IApiVersioningFeature>();
             var method = httpContext.Request.Method;
             var requestUrl = new Lazy<string>( httpContext.Request.GetDisplayUrl );
-            var requestedVersion = properties.RawApiVersion;
-            var parsedVersion = properties.ApiVersion;
+            var requestedVersion = feature.RawRequestedApiVersion;
+            var parsedVersion = feature.RequestedApiVersion;
             var actionNames = new Lazy<string>( () => Join( NewLine, candidates.Select( a => a.DisplayName ) ) );
             var allowedMethods = new Lazy<HashSet<string>>( () => AllowedMethodsFromCandidates( candidates ) );
             var apiVersions = new Lazy<ApiVersionModel>( selectionResult.CandidateActions.SelectMany( l => l.Value.Select( a => a.GetProperty<ApiVersionModel>() ).Where( m => m != null ) ).Aggregate );

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

@@ -152,10 +152,11 @@ public virtual ActionDescriptor SelectBestCandidate( RouteContext context, IRead
 
             var selectionContext = new ActionSelectionContext( httpContext, matches, apiVersion );
             var finalMatches = SelectBestActions( selectionContext );
+            var feature = httpContext.Features.Get<IApiVersioningFeature>();
             var properties = httpContext.ApiVersionProperties();
             var selectionResult = properties.SelectionResult;
 
-            properties.ApiVersion = selectionContext.RequestedVersion;
+            feature.RequestedApiVersion = selectionContext.RequestedVersion;
             selectionResult.AddCandidates( candidates );
 
             if ( finalMatches != null )

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

@@ -0,0 +1,68 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.Extensions.DependencyInjection;
+    using System;
+
+    /// <summary>
+    /// Represents the API versioning feature.
+    /// </summary>
+    public sealed class ApiVersioningFeature : IApiVersioningFeature
+    {
+        readonly HttpContext context;
+        string rawApiVersion;
+        ApiVersion apiVersion;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApiVersioningFeature"/> class.
+        /// </summary>
+        /// <param name="context">The current <see cref="HttpContext">HTTP context</see>.</param>
+        [CLSCompliant( false )]
+        public ApiVersioningFeature( HttpContext context )
+        {
+            Arg.NotNull( context, nameof( context ) );
+            this.context = context;
+        }
+
+        /// <summary>
+        /// Gets or sets the raw, unparsed API version for the current request.
+        /// </summary>
+        /// <value>The unparsed API version value for the current request.</value>
+        public string RawRequestedApiVersion
+        {
+            get
+            {
+                if ( rawApiVersion == null )
+                {
+                    var reader = context.RequestServices.GetService<IApiVersionReader>() ?? new QueryStringApiVersionReader();
+                    rawApiVersion = reader.Read( context.Request );
+                }
+
+                return rawApiVersion;
+            }
+            set => rawApiVersion = value;
+        }
+
+        /// <summary>
+        /// Gets or sets the API version for the current request.
+        /// </summary>
+        /// <value>The current <see cref="ApiVersion">API version</see> for the current request.</value>
+        /// <remarks>If an API version was not provided for the current request or the value
+        /// provided is invalid, this property will return <c>null</c>.</remarks>
+        public ApiVersion RequestedApiVersion
+        {
+            get
+            {
+                if ( apiVersion == null )
+                {
+#pragma warning disable CA1806 // Do not ignore method results
+                    ApiVersion.TryParse( RawRequestedApiVersion, out apiVersion );
+#pragma warning restore CA1806
+                }
+
+                return apiVersion;
+            }
+            set => apiVersion = value;
+        }
+    }
+}

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

@@ -0,0 +1,25 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using Microsoft.AspNetCore.Http;
+    using System.Threading.Tasks;
+
+    sealed class ApiVersioningMiddleware
+    {
+        readonly RequestDelegate next;
+
+        public ApiVersioningMiddleware( RequestDelegate next ) => this.next = next;
+
+        public Task InvokeAsync( HttpContext context )
+        {
+            var feature = context.Features.Get<IApiVersioningFeature>();
+
+            if ( feature == null )
+            {
+                feature = new ApiVersioningFeature( context );
+                context.Features.Set( feature );
+            }
+
+            return next( context );
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using Microsoft.Extensions.DependencyInjection;
+
+    /// <content>
+    /// Provides additional implementation specific to ASP.NET Core.
+    /// </content>
+    public partial class ApiVersioningOptions
+    {
+        /// <summary>
+        /// Gets or sets a value indicating whether the API versioning middleware
+        /// should automatically be registered.
+        /// </summary>
+        /// <value>True if the API versioning middleware should be automatically
+        /// registered; otherwise, false. The default value is <c>true</c>.</value>
+        /// <remarks>If this property is set to false, then
+        /// <see cref="IApplicationBuilderExtensions.UseApiVersioning(Builder.IApplicationBuilder)"/>
+        /// must be called.</remarks>
+        public bool RegisterMiddleware { get; set; } = true;
+    }
+}

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

@@ -0,0 +1,24 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using System;
+
+    /// <summary>
+    /// Defines the behavior of the API versioning feature.
+    /// </summary>
+    public interface IApiVersioningFeature
+    {
+        /// <summary>
+        /// Gets or sets the raw, unparsed API version for the current request.
+        /// </summary>
+        /// <value>The unparsed API version value for the current request.</value>
+        string RawRequestedApiVersion { get; set; }
+
+        /// <summary>
+        /// Gets or sets the API version for the current request.
+        /// </summary>
+        /// <value>The current <see cref="ApiVersion">API version</see> for the current request.</value>
+        /// <remarks>If an API version was not provided for the current request or the value
+        /// provided is invalid, this property will return <c>null</c>.</remarks>
+        ApiVersion RequestedApiVersion { get; set; }
+    }
+}

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

@@ -25,7 +25,8 @@ public virtual string Read( HttpRequest request )
             }
 
             reentrant = true;
-            var value = request.HttpContext.ApiVersionProperties().RawApiVersion;
+            var feature = request.HttpContext.Features.Get<IApiVersioningFeature>();
+            var value = feature.RawRequestedApiVersion;
             reentrant = false;
 
             return value;