Update the ReplaceApplicationManager/ReplaceAuthorizationManager/ReplaceScopeManager/ReplaceTokenManager to register the implementation type as a service

src/OpenIddict.Core/OpenIddictCoreBuilder.cs

@@ -329,11 +329,17 @@ namespace Microsoft.Extensions.DependencyInjection
                     throw new ArgumentException("The specified type is invalid.", nameof(type));
                 }
 
+                Services.Replace(new ServiceDescriptor(type, type, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictApplicationManager<>), type, lifetime));
             }
 
             else
             {
+                object ResolveManager(IServiceProvider provider)
+                    => provider.GetRequiredService(typeof(OpenIddictApplicationManager<>)
+                        .MakeGenericType(root.GenericTypeArguments[0]));
+
+                Services.Replace(new ServiceDescriptor(type, ResolveManager, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictApplicationManager<>)
                     .MakeGenericType(root.GenericTypeArguments[0]), type, lifetime));
             }
@@ -420,11 +426,17 @@ namespace Microsoft.Extensions.DependencyInjection
                     throw new ArgumentException("The specified type is invalid.", nameof(type));
                 }
 
+                Services.Replace(new ServiceDescriptor(type, type, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictAuthorizationManager<>), type, lifetime));
             }
 
             else
             {
+                object ResolveManager(IServiceProvider provider)
+                    => provider.GetRequiredService(typeof(OpenIddictAuthorizationManager<>)
+                        .MakeGenericType(root.GenericTypeArguments[0]));
+
+                Services.Replace(new ServiceDescriptor(type, ResolveManager, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictAuthorizationManager<>)
                     .MakeGenericType(root.GenericTypeArguments[0]), type, lifetime));
             }
@@ -510,11 +522,17 @@ namespace Microsoft.Extensions.DependencyInjection
                     throw new ArgumentException("The specified type is invalid.", nameof(type));
                 }
 
+                Services.Replace(new ServiceDescriptor(type, type, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictScopeManager<>), type, lifetime));
             }
 
             else
             {
+                object ResolveManager(IServiceProvider provider)
+                    => provider.GetRequiredService(typeof(OpenIddictScopeManager<>)
+                        .MakeGenericType(root.GenericTypeArguments[0]));
+
+                Services.Replace(new ServiceDescriptor(type, ResolveManager, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictScopeManager<>)
                     .MakeGenericType(root.GenericTypeArguments[0]), type, lifetime));
             }
@@ -601,11 +619,17 @@ namespace Microsoft.Extensions.DependencyInjection
                     throw new ArgumentException("The specified type is invalid.", nameof(type));
                 }
 
+                Services.Replace(new ServiceDescriptor(type, type, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictTokenManager<>), type, lifetime));
             }
 
             else
             {
+                object ResolveManager(IServiceProvider provider)
+                    => provider.GetRequiredService(typeof(OpenIddictTokenManager<>)
+                        .MakeGenericType(root.GenericTypeArguments[0]));
+
+                Services.Replace(new ServiceDescriptor(type, ResolveManager, lifetime));
                 Services.Replace(new ServiceDescriptor(typeof(OpenIddictTokenManager<>)
                     .MakeGenericType(root.GenericTypeArguments[0]), type, lifetime));
             }

test/OpenIddict.Core.Tests/OpenIddictCoreBuilderTests.cs

@@ -41,6 +41,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceApplicationManager(typeof(OpenGenericApplicationManager<>));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(OpenGenericApplicationManager<>) &&
+                service.ImplementationType == typeof(OpenGenericApplicationManager<>));
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictApplicationManager<>) &&
                 service.ImplementationType == typeof(OpenGenericApplicationManager<>));
@@ -60,6 +63,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceApplicationManager(typeof(ClosedGenericApplicationManager));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(ClosedGenericApplicationManager) &&
+                service.ImplementationFactory != null);
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictApplicationManager<CustomApplication>) &&
                 service.ImplementationType == typeof(ClosedGenericApplicationManager));
@@ -83,7 +89,7 @@ namespace OpenIddict.Core.Tests
         }
 
         [Fact]
-        public void ReplaceApplicationStoreResolver_OverridesDefaultManager()
+        public void ReplaceApplicationStoreResolver_OverridesDefaultResolver()
         {
             // Arrange
             var services = CreateServices();
@@ -126,6 +132,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceAuthorizationManager(typeof(OpenGenericAuthorizationManager<>));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(OpenGenericAuthorizationManager<>) &&
+                service.ImplementationType == typeof(OpenGenericAuthorizationManager<>));
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictAuthorizationManager<>) &&
                 service.ImplementationType == typeof(OpenGenericAuthorizationManager<>));
@@ -145,6 +154,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceAuthorizationManager(typeof(ClosedGenericAuthorizationManager));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(ClosedGenericAuthorizationManager) &&
+                service.ImplementationFactory != null);
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictAuthorizationManager<CustomAuthorization>) &&
                 service.ImplementationType == typeof(ClosedGenericAuthorizationManager));
@@ -167,7 +179,7 @@ namespace OpenIddict.Core.Tests
         }
 
         [Fact]
-        public void ReplaceAuthorizationStoreResolver_OverridesDefaultManager()
+        public void ReplaceAuthorizationStoreResolver_OverridesDefaultResolver()
         {
             // Arrange
             var services = CreateServices();
@@ -210,6 +222,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceScopeManager(typeof(OpenGenericScopeManager<>));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(OpenGenericScopeManager<>) &&
+                service.ImplementationType == typeof(OpenGenericScopeManager<>));
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictScopeManager<>) &&
                 service.ImplementationType == typeof(OpenGenericScopeManager<>));
@@ -229,6 +244,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceScopeManager(typeof(ClosedGenericScopeManager));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(ClosedGenericScopeManager) &&
+                service.ImplementationFactory != null);
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictScopeManager<CustomScope>) &&
                 service.ImplementationType == typeof(ClosedGenericScopeManager));
@@ -252,7 +270,7 @@ namespace OpenIddict.Core.Tests
         }
 
         [Fact]
-        public void ReplaceScopeStoreResolver_OverridesDefaultManager()
+        public void ReplaceScopeStoreResolver_OverridesDefaultResolver()
         {
             // Arrange
             var services = CreateServices();
@@ -295,6 +313,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceTokenManager(typeof(OpenGenericTokenManager<>));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(OpenGenericTokenManager<>) &&
+                service.ImplementationType == typeof(OpenGenericTokenManager<>));
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictTokenManager<>) &&
                 service.ImplementationType == typeof(OpenGenericTokenManager<>));
@@ -314,6 +335,9 @@ namespace OpenIddict.Core.Tests
             builder.ReplaceTokenManager(typeof(ClosedGenericTokenManager));
 
             // Assert
+            Assert.Contains(services, service =>
+                service.ServiceType == typeof(ClosedGenericTokenManager) &&
+                service.ImplementationFactory != null);
             Assert.Contains(services, service =>
                 service.ServiceType == typeof(OpenIddictTokenManager<CustomToken>) &&
                 service.ImplementationType == typeof(ClosedGenericTokenManager));
@@ -337,7 +361,7 @@ namespace OpenIddict.Core.Tests
         }
 
         [Fact]
-        public void ReplaceTokenStoreResolver_OverridesDefaultManager()
+        public void ReplaceTokenStoreResolver_OverridesDefaultResolver()
         {
             // Arrange
             var services = CreateServices();