Add option to support qualified names in URL generation and deprecate operation-specific option

Author: Chris Martinez

src/Common.OData.ApiExplorer/AspNet.OData/Routing/ODataRouteBuilder.cs

@@ -143,11 +143,7 @@ void AppendEntitySetOrOperation( IList<string> segments )
                     AppendEntityKeysFromConvention( builder );
                     segments.Add( builder.ToString() );
                     builder.Clear();
-#if API_EXPLORER
-                    builder.Append( Context.Options.UseQualifiedOperationNames ? Context.Operation.ShortQualifiedName() : Context.Operation.Name );
-#else
-                    builder.Append( Context.Operation.ShortQualifiedName() );
-#endif
+                    builder.Append( Context.Options.UseQualifiedNames ? Context.Operation.ShortQualifiedName() : Context.Operation.Name );
                     AppendParametersFromConvention( builder, Context.Operation );
                     break;
                 case UnboundOperation:

src/Common.OData.ApiExplorer/AspNet.OData/Routing/ODataRouteBuilderContext.cs

@@ -5,6 +5,7 @@
     using Microsoft.AspNetCore.Mvc.Abstractions;
     using Microsoft.AspNetCore.Mvc.ApiExplorer;
     using Microsoft.AspNetCore.Mvc.Controllers;
+    using Microsoft.AspNetCore.Mvc.Versioning;
 #endif
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.OData;
@@ -38,6 +39,8 @@ sealed partial class ODataRouteBuilderContext
 
         internal ODataRouteTemplateGenerationKind RouteTemplateGeneration { get; } = Client;
 #else
+        internal ODataApiVersioningOptions Options { get; }
+
         internal IList<ParameterDescriptor> ParameterDescriptions => ActionDescriptor.Parameters;
 
         internal ODataRouteTemplateGenerationKind RouteTemplateGeneration { get; } = Server;

src/Common.OData.ApiExplorer/ODataApiExplorerOptions.cs

@@ -7,12 +7,14 @@ namespace Microsoft.AspNetCore.Mvc.ApiExplorer
     using Microsoft.AspNet.OData;
     using Microsoft.AspNet.OData.Builder;
     using System;
+    using System.ComponentModel;
 #if WEBAPI
     using System.Web.Http;
     using System.Web.Http.Description;
 #else
     using Microsoft.AspNetCore.Mvc;
 #endif
+    using static System.ComponentModel.EditorBrowsableState;
 
     /// <summary>
     /// Represents the possible API versioning options for an OData API explorer.
@@ -36,7 +38,19 @@ public partial class ODataApiExplorerOptions : ApiExplorerOptions
         /// Gets or sets a value indicating whether qualified names are used when building URLs for operations (e.g. actions and functions).
         /// </summary>
         /// <value>True if qualified names are used when building URLs for operations; otherwise, false. The default value is <c>false</c>.</value>
-        public bool UseQualifiedOperationNames { get; set; }
+        [EditorBrowsable( Never )]
+        [Obsolete( "This property will be removed in the next major version. Use UseQualifiedNames instead.", error: true )]
+        public bool UseQualifiedOperationNames
+        {
+            get => UseQualifiedNames;
+            set => UseQualifiedNames = value;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether qualified names are used when building URLs.
+        /// </summary>
+        /// <value>True if qualified names are used when building URLs; otherwise, false. The default value is <c>false</c>.</value>
+        public bool UseQualifiedNames { get; set; }
 
         /// <summary>
         /// Gets or sets the convention builder used to describe OData query options.

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

@@ -17,7 +17,7 @@ public static class IApplicationBuilderExtensions
         /// <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
+        /// want to control when the middleware is added in the pipeline. API versioning automatically configures
         /// the required middleware, which is usually early enough for dependent middleware.
         /// </para>
         /// <para>

src/Microsoft.AspNetCore.OData.Versioning.ApiExplorer/AspNetCore.Mvc.ApiExplorer/ODataApiDescriptionProvider.cs

@@ -365,7 +365,7 @@ static string BuildRelativePath( ControllerActionDescriptor action, ODataRouteBu
             var relativePath = action.AttributeRouteInfo?.Template;
 
             // note: if path happens to be built adhead of time, it's expected to be qualified; rebuild it as necessary
-            if ( string.IsNullOrEmpty( relativePath ) || !routeContext.Options.UseQualifiedOperationNames )
+            if ( string.IsNullOrEmpty( relativePath ) || !routeContext.Options.UseQualifiedNames )
             {
                 var builder = new ODataRouteBuilder( routeContext );
                 relativePath = builder.Build();

src/Microsoft.AspNetCore.OData.Versioning.ApiExplorer/Extensions.DependencyInjection/IServiceCollectionExtensions.cs

@@ -1,6 +1,7 @@
 namespace Microsoft.Extensions.DependencyInjection
 {
     using Microsoft.AspNetCore.Mvc.ApiExplorer;
+    using Microsoft.AspNetCore.Mvc.Versioning;
     using Microsoft.Extensions.DependencyInjection.Extensions;
     using Microsoft.Extensions.Options;
     using System;
@@ -50,18 +51,29 @@ static void AddApiExplorerServices( IServiceCollection services )
         {
             services.AddVersionedApiExplorer();
             services.TryAdd( Singleton<IOptionsFactory<ODataApiExplorerOptions>, ApiExplorerOptionsFactory<ODataApiExplorerOptions>>() );
-            services.Replace( Singleton<IOptionsFactory<ApiExplorerOptions>>( sp => new ODataApiExplorerOptionsAdapter( sp.GetRequiredService<IOptionsFactory<ODataApiExplorerOptions>>() ) ) );
-            services.Replace( Singleton( typeof( ApiExplorerOptions ), sp => sp.GetRequiredService<ODataApiExplorerOptions>() ) );
+            services.Replace( Singleton<IOptionsFactory<ApiExplorerOptions>, ODataApiExplorerOptionsAdapter>() );
             services.TryAddEnumerable( Transient<IApiDescriptionProvider, ODataApiDescriptionProvider>() );
         }
 
         sealed class ODataApiExplorerOptionsAdapter : IOptionsFactory<ApiExplorerOptions>
         {
+            readonly IOptions<ODataApiVersioningOptions> options;
             readonly IOptionsFactory<ODataApiExplorerOptions> factory;
 
-            internal ODataApiExplorerOptionsAdapter( IOptionsFactory<ODataApiExplorerOptions> factory ) => this.factory = factory;
+            public ODataApiExplorerOptionsAdapter(
+                IOptions<ODataApiVersioningOptions> options,
+                IOptionsFactory<ODataApiExplorerOptions> factory )
+            {
+                this.options = options;
+                this.factory = factory;
+            }
 
-            public ApiExplorerOptions Create( string name ) => factory.Create( name );
+            public ApiExplorerOptions Create( string name )
+            {
+                var newOptions = factory.Create( name );
+                newOptions.UseQualifiedNames = options.Value.UseQualifiedNames;
+                return newOptions;
+            }
         }
     }
 }

src/Microsoft.AspNetCore.OData.Versioning/AspNet.OData/Routing/ODataRouteBindingInfoConvention.cs

@@ -5,6 +5,8 @@
     using Microsoft.AspNetCore.Mvc.Controllers;
     using Microsoft.AspNetCore.Mvc.ModelBinding;
     using Microsoft.AspNetCore.Mvc.Routing;
+    using Microsoft.AspNetCore.Mvc.Versioning;
+    using Microsoft.Extensions.Options;
     using Microsoft.OData.Edm;
     using System;
     using System.Collections.Generic;
@@ -18,21 +20,28 @@
 
     sealed class ODataRouteBindingInfoConvention : IODataActionDescriptorConvention
     {
+        readonly IOptions<ODataApiVersioningOptions> options;
+
         internal ODataRouteBindingInfoConvention(
             IODataRouteCollectionProvider routeCollectionProvider,
-            IModelMetadataProvider modelMetadataProvider )
+            IModelMetadataProvider modelMetadataProvider,
+            IOptions<ODataApiVersioningOptions> options )
         {
             Contract.Requires( routeCollectionProvider != null );
             Contract.Requires( modelMetadataProvider != null );
+            Contract.Requires( options != null );
 
             RouteCollectionProvider = routeCollectionProvider;
             ModelMetadataProvider = modelMetadataProvider;
+            this.options = options;
         }
 
         IODataRouteCollectionProvider RouteCollectionProvider { get; }
 
         IModelMetadataProvider ModelMetadataProvider { get; }
 
+        ODataApiVersioningOptions Options => options.Value;
+
         public void Apply( ActionDescriptorProviderContext context, ControllerActionDescriptor action )
         {
             Contract.Requires( context != null );
@@ -95,7 +104,7 @@ void UpdateBindingInfo( ControllerActionDescriptor action, ODataRouteMapping map
             Contract.Requires( mapping != null );
             Contract.Requires( routeInfos != null );
 
-            var routeContext = new ODataRouteBuilderContext( mapping, action );
+            var routeContext = new ODataRouteBuilderContext( mapping, action, Options );
             var routeBuilder = new ODataRouteBuilder( routeContext );
             var parameterContext = new ActionParameterContext( routeBuilder, routeContext );
 

src/Microsoft.AspNetCore.OData.Versioning/AspNet.OData/Routing/ODataRouteBuilderContext.Core.cs

@@ -2,6 +2,7 @@
 {
     using Microsoft.AspNet.OData;
     using Microsoft.AspNetCore.Mvc.Controllers;
+    using Microsoft.AspNetCore.Mvc.Versioning;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.OData;
     using Microsoft.OData.Edm;
@@ -15,10 +16,14 @@ partial class ODataRouteBuilderContext
     {
         private IODataPathTemplateHandler templateHandler;
 
-        internal ODataRouteBuilderContext( ODataRouteMapping routeMapping, ControllerActionDescriptor actionDescriptor )
+        internal ODataRouteBuilderContext(
+            ODataRouteMapping routeMapping,
+            ControllerActionDescriptor actionDescriptor,
+            ODataApiVersioningOptions options )
         {
             Contract.Requires( routeMapping != null );
             Contract.Requires( actionDescriptor != null );
+            Contract.Requires( options != null );
 
             ApiVersion = routeMapping.ApiVersion;
             serviceProvider = routeMapping.Services;
@@ -27,6 +32,7 @@ internal ODataRouteBuilderContext( ODataRouteMapping routeMapping, ControllerAct
             RouteTemplate = routeAttribute?.PathTemplate;
             Route = routeMapping.Route;
             ActionDescriptor = actionDescriptor;
+            Options = options;
             UrlKeyDelimiter = serviceProvider.GetRequiredService<ODataOptions>().UrlKeyDelimiter ?? Parentheses;
 
             var container = EdmModel.EntityContainer;

src/Microsoft.AspNetCore.OData.Versioning/AspNetCore.Mvc/ODataActionDescriptorProvider.cs

@@ -3,31 +3,32 @@
     using Microsoft.AspNet.OData;
     using Microsoft.AspNet.OData.Routing;
     using Microsoft.AspNetCore.Mvc.Abstractions;
-    using Microsoft.AspNetCore.Mvc.ApplicationParts;
     using Microsoft.AspNetCore.Mvc.Controllers;
     using Microsoft.AspNetCore.Mvc.ModelBinding;
+    using Microsoft.AspNetCore.Mvc.Versioning;
+    using Microsoft.Extensions.Options;
     using System.Collections.Generic;
     using System.Diagnostics.Contracts;
     using System.Linq;
 
     sealed class ODataActionDescriptorProvider : IActionDescriptorProvider
     {
         readonly IODataRouteCollectionProvider routeCollectionProvider;
-        readonly ApplicationPartManager partManager;
         readonly IModelMetadataProvider modelMetadataProvider;
+        readonly IOptions<ODataApiVersioningOptions> options;
 
         public ODataActionDescriptorProvider(
             IODataRouteCollectionProvider routeCollectionProvider,
-            ApplicationPartManager partManager,
-            IModelMetadataProvider modelMetadataProvider )
+            IModelMetadataProvider modelMetadataProvider,
+            IOptions<ODataApiVersioningOptions> options )
         {
             Contract.Requires( routeCollectionProvider != null );
-            Contract.Requires( partManager != null );
             Contract.Requires( modelMetadataProvider != null );
+            Contract.Requires( options != null );
 
             this.routeCollectionProvider = routeCollectionProvider;
-            this.partManager = partManager;
             this.modelMetadataProvider = modelMetadataProvider;
+            this.options = options;
         }
 
         public int Order => 0;
@@ -45,7 +46,7 @@ public void OnProvidersExecuted( ActionDescriptorProviderContext context )
             var conventions = new IODataActionDescriptorConvention[]
             {
                 new ImplicitHttpMethodConvention(),
-                new ODataRouteBindingInfoConvention( routeCollectionProvider, modelMetadataProvider ),
+                new ODataRouteBindingInfoConvention( routeCollectionProvider, modelMetadataProvider, options ),
             };
 
             foreach ( var action in ODataActions( results ) )

src/Microsoft.AspNetCore.OData.Versioning/AspNetCore.Mvc/Versioning/ODataApiVersioningOptions.cs

@@ -31,5 +31,11 @@ public ApiVersionConventionBuilder Conventions
                 conventions = value;
             }
         }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether qualified names are used when building URLs.
+        /// </summary>
+        /// <value>True if qualified names are used when building URLs; otherwise, false. The default value is <c>false</c>.</value>
+        public bool UseQualifiedNames { get; set; }
     }
 }