Refactor to use a default internal container and dependency resolver instead of static singletons

Author: commonsensesoftware

src/AspNet/OData/test/Asp.Versioning.WebApi.OData.Tests/Controllers/VersionedMetadataControllerTest.cs

@@ -37,6 +37,7 @@ public async Task options_should_return_expected_headers()
         configuration.AddApiVersioning(
             options =>
             {
+                options.ReportApiVersions = true;
                 options.Policies.Sunset( "VersionedMetadata" )
                                 .Link( "policies" )
                                     .Title( "Versioning Policy" )

src/AspNet/WebApi/src/Asp.Versioning.WebApi.ApiExplorer/ApiExplorer/VersionedApiExplorer.cs

@@ -101,7 +101,7 @@ public IDocumentationProvider DocumentationProvider
     /// <value>The configured <see cref="ISunsetPolicyManager">sunset policy manager</see>.</value>
     protected ISunsetPolicyManager SunsetPolicyManager
     {
-        get => sunsetPolicyManager ??= Configuration.DependencyResolver.GetSunsetPolicyManager();
+        get => sunsetPolicyManager ??= Configuration.GetSunsetPolicyManager();
         set => sunsetPolicyManager = value;
     }
 
@@ -227,7 +227,7 @@ protected virtual ApiDescriptionGroupCollection InitializeApiDescriptions()
         }
 
         var routes = FlattenRoutes( Configuration.Routes ).ToArray();
-        var policyManager = Configuration.DependencyResolver.GetSunsetPolicyManager();
+        var policyManager = Configuration.GetSunsetPolicyManager();
 
         foreach ( var apiVersion in FlattenApiVersions( controllerMappings ) )
         {

src/AspNet/WebApi/src/Asp.Versioning.WebApi/ApiVersionRequestProperties.cs

@@ -88,7 +88,7 @@ public ApiVersion? RequestedApiVersion
                 return apiVersion;
             }
 
-            var parser = request.GetConfiguration().DependencyResolver.GetApiVersionParser();
+            var parser = request.GetConfiguration().GetApiVersionParser();
 
             try
             {

src/AspNet/WebApi/src/Asp.Versioning.WebApi/DefaultApiVersionReporter.cs

@@ -10,11 +10,6 @@ namespace Asp.Versioning;
 /// </content>
 public partial class DefaultApiVersionReporter
 {
-    private static DefaultApiVersionReporter? instance;
-
-    internal static IReportApiVersions GetOrCreate( ISunsetPolicyManager sunsetPolicyManager ) =>
-        instance ??= new( sunsetPolicyManager );
-
     private static void AddApiVersionHeader( HttpResponseHeaders headers, string headerName, IReadOnlyList<ApiVersion> versions )
     {
         if ( versions.Count == 0 || headers.Contains( headerName ) )

src/AspNet/WebApi/src/Asp.Versioning.WebApi/Dependencies/DefaultContainer.cs

@@ -0,0 +1,84 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+
+namespace Asp.Versioning.Dependencies;
+
+using Asp.Versioning;
+using Asp.Versioning.Conventions;
+using System.ComponentModel.Design;
+using System.Web.Http.Dependencies;
+
+internal sealed class DefaultContainer : IDependencyResolver, IDependencyScope
+{
+    private readonly ServiceContainer container = new();
+    private bool disposed;
+
+    internal DefaultContainer()
+    {
+        container.AddService( typeof( ApiVersioningOptions ), static ( sc, t ) => new ApiVersioningOptions() );
+        container.AddService( typeof( IApiVersionParser ), static ( sc, t ) => ApiVersionParser.Default );
+        container.AddService( typeof( IControllerNameConvention ), static ( sc, t ) => ControllerNameConvention.Default );
+        container.AddService( typeof( IProblemDetailsFactory ), static ( sc, t ) => new ProblemDetailsFactory() );
+        container.AddService( typeof( ISunsetPolicyManager ), NewSunsetPolicyManager );
+        container.AddService( typeof( IReportApiVersions ), NewApiVersionReporter );
+    }
+
+    public ApiVersioningOptions ApiVersioningOptions
+    {
+        get => GetApiVersioningOptions( container );
+        set
+        {
+            container.RemoveService( typeof( ApiVersioningOptions ) );
+            container.AddService( typeof( ApiVersioningOptions ), value );
+        }
+    }
+
+    public void Replace( Type serviceType, ServiceCreatorCallback activator )
+    {
+        container.RemoveService( serviceType );
+        container.AddService( serviceType, activator );
+    }
+
+    public IDependencyScope BeginScope() => this;
+
+    public void Dispose()
+    {
+        if ( disposed )
+        {
+            return;
+        }
+
+        disposed = true;
+        container.Dispose();
+    }
+
+    public object GetService( Type serviceType ) => container.GetService( serviceType );
+
+    public IEnumerable<object> GetServices( Type serviceType )
+    {
+        var service = container.GetService( serviceType );
+
+        if ( service is not null )
+        {
+            yield return service;
+        }
+    }
+
+    private static ApiVersioningOptions GetApiVersioningOptions( IServiceProvider serviceProvider ) =>
+        (ApiVersioningOptions) serviceProvider.GetService( typeof( ApiVersioningOptions ) );
+
+    private static ISunsetPolicyManager NewSunsetPolicyManager( IServiceProvider serviceProvider, Type type ) =>
+        new SunsetPolicyManager( GetApiVersioningOptions( serviceProvider ) );
+
+    private static IReportApiVersions NewApiVersionReporter( IServiceProvider serviceProvider, Type type )
+    {
+        var options = GetApiVersioningOptions( serviceProvider );
+
+        if ( options.ReportApiVersions )
+        {
+            var sunsetPolicyManager = (ISunsetPolicyManager) serviceProvider.GetService( typeof( ISunsetPolicyManager ) );
+            return new DefaultApiVersionReporter( sunsetPolicyManager );
+        }
+
+        return new DoNotReportApiVersions();
+    }
+}

src/AspNet/WebApi/src/Asp.Versioning.WebApi/DependencyResolverExtensions.cs

@@ -3,24 +3,39 @@
 namespace Asp.Versioning;
 
 using Asp.Versioning.Conventions;
+using System.Globalization;
+using System.Web.Http;
 using System.Web.Http.Dependencies;
 
 internal static class DependencyResolverExtensions
 {
-    internal static TService? GetService<TService>( this IDependencyResolver resolver ) => (TService) resolver.GetService( typeof( TService ) );
-
-    internal static IApiVersionParser GetApiVersionParser( this IDependencyResolver resolver ) =>
-        resolver.GetService<IApiVersionParser>() ?? ApiVersionParser.Default;
-
-    internal static IReportApiVersions GetApiVersionReporter( this IDependencyResolver resolver ) =>
-        resolver.GetService<IReportApiVersions>() ?? DefaultApiVersionReporter.GetOrCreate( resolver.GetSunsetPolicyManager() );
-
-    internal static IControllerNameConvention GetControllerNameConvention( this IDependencyResolver resolver ) =>
-        resolver.GetService<IControllerNameConvention>() ?? ControllerNameConvention.Default;
-
-    internal static IProblemDetailsFactory GetProblemDetailsFactory( this IDependencyResolver resolver ) =>
-        resolver.GetService<IProblemDetailsFactory>() ?? ProblemDetailsFactory.Default;
-
-    internal static ISunsetPolicyManager GetSunsetPolicyManager( this IDependencyResolver resolver ) =>
-        resolver.GetService<ISunsetPolicyManager>() ?? SunsetPolicyManager.Default;
+    internal static TService? GetService<TService>( this IDependencyResolver resolver ) =>
+        (TService) resolver.GetService( typeof( TService ) );
+
+    internal static TService GetRequiredService<TService>( this IDependencyResolver resolver )
+    {
+        var service = resolver.GetService<TService>();
+        var message = string.Format( CultureInfo.CurrentCulture, SR.NoServiceRegistered, typeof( TService ) );
+        return service ?? throw new InvalidOperationException( message );
+    }
+
+    internal static IApiVersionParser GetApiVersionParser( this HttpConfiguration configuration ) =>
+        configuration.DependencyResolver.GetService<IApiVersionParser>() ??
+        configuration.ApiVersioningServices().GetRequiredService<IApiVersionParser>();
+
+    internal static IReportApiVersions GetApiVersionReporter( this HttpConfiguration configuration ) =>
+        configuration.DependencyResolver.GetService<IReportApiVersions>() ??
+        configuration.ApiVersioningServices().GetRequiredService<IReportApiVersions>();
+
+    internal static IControllerNameConvention GetControllerNameConvention( this HttpConfiguration configuration ) =>
+        configuration.DependencyResolver.GetService<IControllerNameConvention>() ??
+        configuration.ApiVersioningServices().GetRequiredService<IControllerNameConvention>();
+
+    internal static IProblemDetailsFactory GetProblemDetailsFactory( this HttpConfiguration configuration ) =>
+        configuration.DependencyResolver.GetService<IProblemDetailsFactory>() ??
+        configuration.ApiVersioningServices().GetRequiredService<IProblemDetailsFactory>();
+
+    internal static ISunsetPolicyManager GetSunsetPolicyManager( this HttpConfiguration configuration ) =>
+        configuration.DependencyResolver.GetService<ISunsetPolicyManager>() ??
+        configuration.ApiVersioningServices().GetRequiredService<ISunsetPolicyManager>();
 }

src/AspNet/WebApi/src/Asp.Versioning.WebApi/Dispatcher/ApiVersionControllerSelector.cs

@@ -221,7 +221,7 @@ private static void ApplyImplicitConventions( HttpControllerDescriptor controlle
         }
 
         var actions = mapping.SelectMany( g => g );
-        var namingConvention = controller.Configuration.DependencyResolver.GetControllerNameConvention();
+        var namingConvention = controller.Configuration.GetControllerNameConvention();
         var name = namingConvention.GroupName( controller.ControllerName );
         var metadata = new ApiVersionMetadata( implicitVersionModel, implicitVersionModel, name );
 
@@ -344,7 +344,7 @@ private static void ApplyCollatedModelsToActions(
         HttpConfiguration configuration,
         List<Tuple<HttpControllerDescriptor, HttpActionDescriptor, ApiVersionModel>> visitedActions )
     {
-        var namingConvention = configuration.DependencyResolver.GetControllerNameConvention();
+        var namingConvention = configuration.GetControllerNameConvention();
 
         for ( var i = 0; i < visitedActions.Count; i++ )
         {

src/AspNet/WebApi/src/Asp.Versioning.WebApi/Dispatcher/HttpControllerTypeCache.cs

@@ -33,7 +33,7 @@ private Dictionary<string, ILookup<string, Type>> InitializeCache()
         var services = configuration.Services;
         var assembliesResolver = services.GetAssembliesResolver();
         var typeResolver = services.GetHttpControllerTypeResolver();
-        var convention = configuration.DependencyResolver.GetControllerNameConvention();
+        var convention = configuration.GetControllerNameConvention();
         var comparer = StringComparer.OrdinalIgnoreCase;
 
         return typeResolver.GetControllerTypes( assembliesResolver )

src/AspNet/WebApi/src/Asp.Versioning.WebApi/Dispatcher/HttpResponseExceptionFactory.cs

@@ -36,7 +36,7 @@ internal HttpResponseExceptionFactory( HttpRequestMessage request, ApiVersionMod
 
     private ApiVersioningOptions Options => configuration.GetApiVersioningOptions();
 
-    private IProblemDetailsFactory ProblemDetails => configuration.DependencyResolver.GetProblemDetailsFactory();
+    private IProblemDetailsFactory ProblemDetails => configuration.GetProblemDetailsFactory();
 
     private ITraceWriter TraceWriter => configuration.Services.GetTraceWriter() ?? NullTraceWriter.Instance;
 

src/AspNet/WebApi/src/Asp.Versioning.WebApi/DoNotReportApiVersions.cs

@@ -6,12 +6,6 @@ namespace Asp.Versioning;
 
 internal sealed class DoNotReportApiVersions : IReportApiVersions
 {
-    private static DoNotReportApiVersions? instance;
-
-    private DoNotReportApiVersions() { }
-
-    internal static IReportApiVersions Instance => instance ??= new();
-
     public ApiVersionMapping Mapping => Explicit | Implicit;
 
     public void Report( HttpResponseMessage response, ApiVersionModel apiVersionModel ) { }