Support model binding for API version. Closes #320.

Author: Chris Martinez

src/Microsoft.AspNet.WebApi.Versioning/Controllers/ApiVersionParameterBinding.cs

@@ -0,0 +1,41 @@
+namespace Microsoft.Web.Http.Controllers
+{
+    using System.Diagnostics.Contracts;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Web.Http;
+    using System.Web.Http.Controllers;
+    using System.Web.Http.Metadata;
+
+    /// <summary>
+    /// Represents the binding for an <see cref="ApiVersion">API version</see> parameter.
+    /// </summary>
+    public class ApiVersionParameterBinding : HttpParameterBinding
+    {
+        static readonly Task CompletedTask = Task.FromResult( default( object ) );
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApiVersionParameterBinding"/> class.
+        /// </summary>
+        /// <param name="descriptor">The <see cref="HttpParameterDescriptor">parameter descriptor</see> associated with the binding.</param>
+        public ApiVersionParameterBinding( HttpParameterDescriptor descriptor ) : base( descriptor ) { }
+
+        /// <inheritdoc />
+        public override Task ExecuteBindingAsync( ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken )
+        {
+            Contract.Assert( metadataProvider != null );
+            Contract.Assert( actionContext != null );
+
+            var value = actionContext.Request.ApiVersionProperties().RequestedApiVersion;
+            SetValue( actionContext, value );
+            return CompletedTask;
+        }
+
+        /// <summary>
+        /// Creates and returns a new parameter binding for the specified descriptor.
+        /// </summary>
+        /// <param name="descriptor">The <see cref="HttpParameterDescriptor">parameter descriptor</see> to create a binding for.</param>
+        /// <returns>A new <see cref="HttpParameterBinding">parameter binding</see>.</returns>
+        public static HttpParameterBinding Create( HttpParameterDescriptor descriptor ) => new ApiVersionParameterBinding( descriptor );
+    }
+}

src/Microsoft.AspNet.WebApi.Versioning/System.Web.Http/HttpConfigurationExtensions.cs

@@ -1,13 +1,13 @@
 namespace System.Web.Http
 {
-    using System.Diagnostics.Contracts;
-    using System.Web.Http.Controllers;
-    using System.Web.Http.Dispatcher;
     using Microsoft;
     using Microsoft.Web.Http;
     using Microsoft.Web.Http.Controllers;
     using Microsoft.Web.Http.Dispatcher;
     using Microsoft.Web.Http.Versioning;
+    using System.Diagnostics.Contracts;
+    using System.Web.Http.Controllers;
+    using System.Web.Http.Dispatcher;
 
     /// <summary>
     /// Provides extension methods for the <see cref="HttpConfiguration"/> class.
@@ -58,6 +58,7 @@ public static void AddApiVersioning( this HttpConfiguration configuration, Actio
             }
 
             configuration.Properties.AddOrUpdate( ApiVersioningOptionsKey, options, ( key, oldValue ) => options );
+            configuration.ParameterBindingRules.Add( typeof( ApiVersion ), ApiVersionParameterBinding.Create );
         }
     }
 }

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

@@ -0,0 +1,28 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using Microsoft.AspNetCore.Mvc.ModelBinding;
+    using System;
+    using System.Diagnostics.Contracts;
+    using System.Threading.Tasks;
+    using static System.Threading.Tasks.Task;
+
+    /// <summary>
+    /// Represents a model binder for an <see cref="ApiVersion">API version</see>.
+    /// </summary>
+    [CLSCompliant( false )]
+    public class ApiVersionModelBinder : IModelBinder
+    {
+        /// <inheritdoc />
+        public virtual Task BindModelAsync( ModelBindingContext bindingContext )
+        {
+            Contract.Assert( bindingContext != null );
+
+            var feature = bindingContext.HttpContext.Features.Get<IApiVersioningFeature>();
+            var model = feature.RequestedApiVersion;
+
+            bindingContext.Result = ModelBindingResult.Success( model );
+
+            return CompletedTask;
+        }
+    }
+}

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

@@ -0,0 +1,24 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using Microsoft.AspNetCore.Mvc.ModelBinding;
+    using System;
+    using System.Diagnostics.Contracts;
+
+    sealed class ApiVersionModelBinderProvider : IModelBinderProvider
+    {
+        static readonly Type ApiVersionType = typeof( ApiVersion );
+        static readonly ApiVersionModelBinder binder = new ApiVersionModelBinder();
+
+        public IModelBinder GetBinder( ModelBinderProviderContext context )
+        {
+            Contract.Assert( context != null );
+
+            if ( context.Metadata.ModelType.IsAssignableFrom( ApiVersionType ) )
+            {
+                return binder;
+            }
+
+            return default;
+        }
+    }
+}

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

@@ -26,6 +26,8 @@ public virtual void PostConfigure( string name, MvcOptions options )
             {
                 options.Filters.AddService<ReportApiVersionsAttribute>();
             }
+
+            options.ModelBinderProviders.Insert( 0, new ApiVersionModelBinderProvider() );
         }
     }
 }

test/Microsoft.AspNet.WebApi.Versioning.Tests/Controllers/ApiVersionParameterBindingTest.cs

@@ -0,0 +1,68 @@
+namespace Microsoft.Web.Http.Controllers
+{
+    using FluentAssertions;
+    using Moq;
+    using System.Net.Http;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Web.Http;
+    using System.Web.Http.Controllers;
+    using System.Web.Http.Metadata;
+    using Xunit;
+
+    public class ApiVersionParameterBindingTest
+    {
+        [Fact]
+        public async Task execute_async_should_bind_parameter_value()
+        {
+            // arrange
+            var apiVersion = new ApiVersion( 42, 0 );
+            var metadataProvider = Mock.Of<ModelMetadataProvider>();
+            var actionContext = NewActionContext( apiVersion );
+            var parameter = NewParameter( nameof( apiVersion ) );
+            var binding = new ApiVersionParameterBinding( parameter );
+
+            // act
+            await binding.ExecuteBindingAsync( metadataProvider, actionContext, CancellationToken.None );
+
+            // assert
+            actionContext.ActionArguments[nameof( apiVersion )].Should().Be( apiVersion );
+        }
+
+        [Fact]
+        public async Task execute_async_should_bind_null_parameter_value()
+        {
+            // arrange
+            var metadataProvider = Mock.Of<ModelMetadataProvider>();
+            var actionContext = NewActionContext( default );
+            var parameter = NewParameter( "requestedApiVersion" );
+            var binding = new ApiVersionParameterBinding( parameter );
+
+            // act
+            await binding.ExecuteBindingAsync( metadataProvider, actionContext, CancellationToken.None );
+
+            // assert
+            actionContext.ActionArguments["requestedApiVersion"].Should().BeNull();
+        }
+
+        static HttpActionContext NewActionContext( ApiVersion apiVersion )
+        {
+            var configuration = new HttpConfiguration();
+            var request = new HttpRequestMessage();
+            var controllerContext = new HttpControllerContext() { Configuration = configuration, Request = request };
+            var actionContext = new HttpActionContext() { ControllerContext = controllerContext };
+
+            request.SetConfiguration( configuration );
+            request.ApiVersionProperties().RequestedApiVersion = apiVersion;
+
+            return actionContext;
+        }
+
+        static HttpParameterDescriptor NewParameter( string name )
+        {
+            var parameter = new Mock<HttpParameterDescriptor>();
+            parameter.Setup( p => p.ParameterName ).Returns( name );
+            return parameter.Object;
+        }
+    }
+}

test/Microsoft.AspNetCore.Mvc.Versioning.Tests/Versioning/ApiVersionModelBinderTest.cs

@@ -0,0 +1,67 @@
+namespace Microsoft.AspNetCore.Mvc.Versioning
+{
+    using FluentAssertions;
+    using Microsoft.AspNetCore.Http;
+    using Microsoft.AspNetCore.Http.Features;
+    using Microsoft.AspNetCore.Mvc.ModelBinding;
+    using Moq;
+    using System.Threading.Tasks;
+    using Xunit;
+
+    public class ApiVersionModelBinderTest
+    {
+        [Fact]
+        public async Task bind_model_should_set_api_version_as_result()
+        {
+            // arrange
+            var apiVersion = new ApiVersion( 42, 0 );
+            var bindingContext = NewModelBindingContext( apiVersion );
+            var binder = new ApiVersionModelBinder();
+
+            // act
+            await binder.BindModelAsync( bindingContext );
+
+            // assert
+            bindingContext.Result.Model.Should().Be( apiVersion );
+        }
+
+        [Fact]
+        public async Task bind_model_should_set_null_api_version_as_result()
+        {
+            // arrange
+            var bindingContext = NewModelBindingContext( default );
+            var binder = new ApiVersionModelBinder();
+
+            // act
+            await binder.BindModelAsync( bindingContext );
+
+            // assert
+            bindingContext.Result.IsModelSet.Should().BeTrue();
+            bindingContext.Result.Model.Should().BeNull();
+        }
+
+        static HttpContext NewHttpContext( ApiVersion apiVersion )
+        {
+            var feature = new Mock<IApiVersioningFeature>();
+            var featureCollection = new Mock<IFeatureCollection>();
+            var httpContext = new Mock<HttpContext>();
+
+            feature.SetupProperty( f => f.RequestedApiVersion, apiVersion );
+            featureCollection.Setup( fc => fc.Get<IApiVersioningFeature>() ).Returns( feature.Object );
+            httpContext.SetupGet( hc => hc.Features ).Returns( featureCollection.Object );
+
+            return httpContext.Object;
+        }
+
+        static ModelBindingContext NewModelBindingContext( ApiVersion apiVersion )
+        {
+            var httpContext = NewHttpContext( apiVersion );
+            var bindingContext = new Mock<ModelBindingContext>();
+
+            bindingContext.SetupGet( bc => bc.HttpContext ).Returns( httpContext );
+            bindingContext.SetupProperty( bc => bc.Result );
+
+            return bindingContext.Object;
+        }
+    }
+}