diff --git a/src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkExtensions.cs b/src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkExtensions.cs
index 474b4a9c..f2ed4313 100644
--- a/src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkExtensions.cs
+++ b/src/OpenIddict.EntityFramework/OpenIddictEntityFrameworkExtensions.cs
@@ -46,6 +46,11 @@ namespace Microsoft.Extensions.DependencyInjection
                    .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>()
                    .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>();
 
+            builder.Services.TryAddSingleton<OpenIddictApplicationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictAuthorizationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictScopeStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictTokenStoreResolver.TypeResolutionCache>();
+
             builder.Services.TryAddScoped(typeof(OpenIddictApplicationStore<,,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictAuthorizationStore<,,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictScopeStore<,,>));
diff --git a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictApplicationStoreResolver.cs b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictApplicationStoreResolver.cs
index 044cfa11..05f5491d 100644
--- a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictApplicationStoreResolver.cs
+++ b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictApplicationStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFramework
     /// </summary>
     public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictApplicationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFramework
 
             return (IOpenIddictApplicationStore<TApplication>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictAuthorizationStoreResolver.cs b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictAuthorizationStoreResolver.cs
index 9683733d..a037d42b 100644
--- a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictAuthorizationStoreResolver.cs
+++ b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictAuthorizationStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFramework
     /// </summary>
     public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictAuthorizationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFramework
 
             return (IOpenIddictAuthorizationStore<TAuthorization>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictScopeStoreResolver.cs b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictScopeStoreResolver.cs
index cfe05634..74ffc732 100644
--- a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictScopeStoreResolver.cs
+++ b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictScopeStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFramework
     /// </summary>
     public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictScopeStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -78,5 +80,11 @@ namespace OpenIddict.EntityFramework
 
             return (IOpenIddictScopeStore<TScope>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictTokenStoreResolver.cs b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictTokenStoreResolver.cs
index eebd7503..7bd07398 100644
--- a/src/OpenIddict.EntityFramework/Resolvers/OpenIddictTokenStoreResolver.cs
+++ b/src/OpenIddict.EntityFramework/Resolvers/OpenIddictTokenStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFramework
     /// </summary>
     public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictTokenStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFramework
 
             return (IOpenIddictTokenStore<TToken>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreExtensions.cs b/src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreExtensions.cs
index c32d2eb3..90d3d156 100644
--- a/src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreExtensions.cs
+++ b/src/OpenIddict.EntityFrameworkCore/OpenIddictEntityFrameworkCoreExtensions.cs
@@ -46,6 +46,11 @@ namespace Microsoft.Extensions.DependencyInjection
                    .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>()
                    .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>();
 
+            builder.Services.TryAddSingleton<OpenIddictApplicationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictAuthorizationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictScopeStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictTokenStoreResolver.TypeResolutionCache>();
+
             builder.Services.TryAddScoped(typeof(OpenIddictApplicationStore<,,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictAuthorizationStore<,,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictScopeStore<,,>));
diff --git a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictApplicationStoreResolver.cs b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictApplicationStoreResolver.cs
index 030a0f2c..4441aafb 100644
--- a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictApplicationStoreResolver.cs
+++ b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictApplicationStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictApplicationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFrameworkCore
 
             return (IOpenIddictApplicationStore<TApplication>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework Core resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictAuthorizationStoreResolver.cs b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictAuthorizationStoreResolver.cs
index 8964735e..eda0e4d8 100644
--- a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictAuthorizationStoreResolver.cs
+++ b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictAuthorizationStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictAuthorizationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFrameworkCore
 
             return (IOpenIddictAuthorizationStore<TAuthorization>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework Core resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictScopeStoreResolver.cs b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictScopeStoreResolver.cs
index 9c249b78..ed65f16a 100644
--- a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictScopeStoreResolver.cs
+++ b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictScopeStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictScopeStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -78,5 +80,11 @@ namespace OpenIddict.EntityFrameworkCore
 
             return (IOpenIddictScopeStore<TScope>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework Core resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictTokenStoreResolver.cs b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictTokenStoreResolver.cs
index 860ca846..07c3304a 100644
--- a/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictTokenStoreResolver.cs
+++ b/src/OpenIddict.EntityFrameworkCore/Resolvers/OpenIddictTokenStoreResolver.cs
@@ -21,14 +21,16 @@ namespace OpenIddict.EntityFrameworkCore
     /// </summary>
     public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> _options;
         private readonly IServiceProvider _provider;
 
         public OpenIddictTokenStoreResolver(
+            [NotNull] TypeResolutionCache cache,
             [NotNull] IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions> options,
             [NotNull] IServiceProvider provider)
         {
+            _cache = cache;
             _options = options;
             _provider = provider;
         }
@@ -80,5 +82,11 @@ namespace OpenIddict.EntityFrameworkCore
 
             return (IOpenIddictTokenStore<TToken>) _provider.GetRequiredService(type);
         }
+
+        // Note: Entity Framework Core resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.NHibernate/OpenIddictNHibernateExtensions.cs b/src/OpenIddict.NHibernate/OpenIddictNHibernateExtensions.cs
index 99ea9061..16d29d61 100644
--- a/src/OpenIddict.NHibernate/OpenIddictNHibernateExtensions.cs
+++ b/src/OpenIddict.NHibernate/OpenIddictNHibernateExtensions.cs
@@ -46,6 +46,11 @@ namespace Microsoft.Extensions.DependencyInjection
                    .ReplaceScopeStoreResolver<OpenIddictScopeStoreResolver>()
                    .ReplaceTokenStoreResolver<OpenIddictTokenStoreResolver>();
 
+            builder.Services.TryAddSingleton<OpenIddictApplicationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictAuthorizationStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictScopeStoreResolver.TypeResolutionCache>();
+            builder.Services.TryAddSingleton<OpenIddictTokenStoreResolver.TypeResolutionCache>();
+
             builder.Services.TryAddScoped(typeof(OpenIddictApplicationStore<,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictAuthorizationStore<,,,>));
             builder.Services.TryAddScoped(typeof(OpenIddictScopeStore<,>));
diff --git a/src/OpenIddict.NHibernate/Resolvers/OpenIddictApplicationStoreResolver.cs b/src/OpenIddict.NHibernate/Resolvers/OpenIddictApplicationStoreResolver.cs
index 90a6efca..450bbb08 100644
--- a/src/OpenIddict.NHibernate/Resolvers/OpenIddictApplicationStoreResolver.cs
+++ b/src/OpenIddict.NHibernate/Resolvers/OpenIddictApplicationStoreResolver.cs
@@ -20,11 +20,16 @@ namespace OpenIddict.NHibernate
     /// </summary>
     public class OpenIddictApplicationStoreResolver : IOpenIddictApplicationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictApplicationStoreResolver([NotNull] IServiceProvider provider)
-            => _provider = provider;
+        public OpenIddictApplicationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
+            [NotNull] IServiceProvider provider)
+        {
+            _cache = cache;
+            _provider = provider;
+        }
 
         /// <summary>
         /// Returns an application store compatible with the specified application type or throws an
@@ -62,5 +67,11 @@ namespace OpenIddict.NHibernate
 
             return (IOpenIddictApplicationStore<TApplication>) _provider.GetRequiredService(type);
         }
+
+        // Note: NHibernate resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.NHibernate/Resolvers/OpenIddictAuthorizationStoreResolver.cs b/src/OpenIddict.NHibernate/Resolvers/OpenIddictAuthorizationStoreResolver.cs
index eca5a5a0..401f902b 100644
--- a/src/OpenIddict.NHibernate/Resolvers/OpenIddictAuthorizationStoreResolver.cs
+++ b/src/OpenIddict.NHibernate/Resolvers/OpenIddictAuthorizationStoreResolver.cs
@@ -20,11 +20,16 @@ namespace OpenIddict.NHibernate
     /// </summary>
     public class OpenIddictAuthorizationStoreResolver : IOpenIddictAuthorizationStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictAuthorizationStoreResolver([NotNull] IServiceProvider provider)
-            => _provider = provider;
+        public OpenIddictAuthorizationStoreResolver(
+            [NotNull] TypeResolutionCache cache,
+            [NotNull] IServiceProvider provider)
+        {
+            _cache = cache;
+            _provider = provider;
+        }
 
         /// <summary>
         /// Returns an authorization store compatible with the specified authorization type or throws an
@@ -62,5 +67,11 @@ namespace OpenIddict.NHibernate
 
             return (IOpenIddictAuthorizationStore<TAuthorization>) _provider.GetRequiredService(type);
         }
+
+        // Note: NHibernate resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.NHibernate/Resolvers/OpenIddictScopeStoreResolver.cs b/src/OpenIddict.NHibernate/Resolvers/OpenIddictScopeStoreResolver.cs
index 1d29e5b3..3edd0a7c 100644
--- a/src/OpenIddict.NHibernate/Resolvers/OpenIddictScopeStoreResolver.cs
+++ b/src/OpenIddict.NHibernate/Resolvers/OpenIddictScopeStoreResolver.cs
@@ -20,11 +20,16 @@ namespace OpenIddict.NHibernate
     /// </summary>
     public class OpenIddictScopeStoreResolver : IOpenIddictScopeStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictScopeStoreResolver([NotNull] IServiceProvider provider)
-            => _provider = provider;
+        public OpenIddictScopeStoreResolver(
+            [NotNull] TypeResolutionCache cache,
+            [NotNull] IServiceProvider provider)
+        {
+            _cache = cache;
+            _provider = provider;
+        }
 
         /// <summary>
         /// Returns a scope store compatible with the specified scope type or throws an
@@ -60,5 +65,11 @@ namespace OpenIddict.NHibernate
 
             return (IOpenIddictScopeStore<TScope>) _provider.GetRequiredService(type);
         }
+
+        // Note: NHibernate resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/src/OpenIddict.NHibernate/Resolvers/OpenIddictTokenStoreResolver.cs b/src/OpenIddict.NHibernate/Resolvers/OpenIddictTokenStoreResolver.cs
index 5840e9b4..f6bc99c2 100644
--- a/src/OpenIddict.NHibernate/Resolvers/OpenIddictTokenStoreResolver.cs
+++ b/src/OpenIddict.NHibernate/Resolvers/OpenIddictTokenStoreResolver.cs
@@ -20,11 +20,16 @@ namespace OpenIddict.NHibernate
     /// </summary>
     public class OpenIddictTokenStoreResolver : IOpenIddictTokenStoreResolver
     {
-        private static readonly ConcurrentDictionary<Type, Type> _cache = new ConcurrentDictionary<Type, Type>();
+        private readonly TypeResolutionCache _cache;
         private readonly IServiceProvider _provider;
 
-        public OpenIddictTokenStoreResolver([NotNull] IServiceProvider provider)
-            => _provider = provider;
+        public OpenIddictTokenStoreResolver(
+            [NotNull] TypeResolutionCache cache,
+            [NotNull] IServiceProvider provider)
+        {
+            _cache = cache;
+            _provider = provider;
+        }
 
         /// <summary>
         /// Returns a token store compatible with the specified token type or throws an
@@ -62,5 +67,11 @@ namespace OpenIddict.NHibernate
 
             return (IOpenIddictTokenStore<TToken>) _provider.GetRequiredService(type);
         }
+
+        // Note: NHibernate resolvers are registered as scoped dependencies as their inner
+        // service provider must be able to resolve scoped services (typically, the store they return).
+        // To avoid having to declare a static type resolution cache, a special cache service is used
+        // here and registered as a singleton dependency so that its content persists beyond the scope.
+        public class TypeResolutionCache : ConcurrentDictionary<Type, Type> { }
     }
 }
diff --git a/test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkExtensionsTests.cs b/test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkExtensionsTests.cs
index 2fd603dc..3e893833 100644
--- a/test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkExtensionsTests.cs
+++ b/test/OpenIddict.EntityFramework.Tests/OpenIddictEntityFrameworkExtensionsTests.cs
@@ -80,6 +80,25 @@ namespace OpenIddict.EntityFramework.Tests
                                                  service.ImplementationType == implementationType);
         }
 
+        [Theory]
+        [InlineData(typeof(OpenIddictApplicationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictAuthorizationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictScopeStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictTokenStoreResolver.TypeResolutionCache))]
+        public void UseEntityFramework_RegistersEntityFrameworkStoreResolverCaches(Type type)
+        {
+            // Arrange
+            var services = new ServiceCollection();
+            var builder = new OpenIddictCoreBuilder(services);
+
+            // Act
+            builder.UseEntityFramework();
+
+            // Assert
+            Assert.Contains(services, service => service.ServiceType == type &&
+                                                 service.ImplementationType == type);
+        }
+
         [Theory]
         [InlineData(typeof(OpenIddictApplicationStore<,,,,>))]
         [InlineData(typeof(OpenIddictAuthorizationStore<,,,,>))]
diff --git a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
index f21ad750..f623d3c1 100644
--- a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
+using static OpenIddict.EntityFramework.OpenIddictApplicationStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictApplication>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
diff --git a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
index 2ac870fd..329dd09e 100644
--- a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
+using static OpenIddict.EntityFramework.OpenIddictAuthorizationStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictAuthorization>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
diff --git a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
index 1e66222a..8d3db847 100644
--- a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
+using static OpenIddict.EntityFramework.OpenIddictScopeStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictScope>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
diff --git a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
index cfe13b5d..6903d605 100644
--- a/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFramework.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFramework.Models;
 using Xunit;
+using static OpenIddict.EntityFramework.OpenIddictTokenStoreResolver;
 
 namespace OpenIddict.EntityFramework.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFramework.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictToken>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFramework.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());
diff --git a/test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreExtensionsTests.cs b/test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreExtensionsTests.cs
index 482a7f1a..6b2222b6 100644
--- a/test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreExtensionsTests.cs
+++ b/test/OpenIddict.EntityFrameworkCore.Tests/OpenIddictEntityFrameworkCoreExtensionsTests.cs
@@ -80,6 +80,25 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                                                  service.ImplementationType == implementationType);
         }
 
+        [Theory]
+        [InlineData(typeof(OpenIddictApplicationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictAuthorizationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictScopeStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictTokenStoreResolver.TypeResolutionCache))]
+        public void UseEntityFrameworkCore_RegistersEntityFrameworkCoreStoreResolverCaches(Type type)
+        {
+            // Arrange
+            var services = new ServiceCollection();
+            var builder = new OpenIddictCoreBuilder(services);
+
+            // Act
+            builder.UseEntityFrameworkCore();
+
+            // Assert
+            Assert.Contains(services, service => service.ServiceType == type &&
+                                                 service.ImplementationType == type);
+        }
+
         [Theory]
         [InlineData(typeof(OpenIddictApplicationStore<,,,,>))]
         [InlineData(typeof(OpenIddictAuthorizationStore<,,,,>))]
diff --git a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
index 9e6bfe4c..2fefb1b1 100644
--- a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
+using static OpenIddict.EntityFrameworkCore.OpenIddictApplicationStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictApplication>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(options, provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
diff --git a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
index ef04c8d7..e58821fc 100644
--- a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
+using static OpenIddict.EntityFrameworkCore.OpenIddictAuthorizationStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictAuthorization>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(options, provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
diff --git a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
index b46003e9..89fea545 100644
--- a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
+using static OpenIddict.EntityFrameworkCore.OpenIddictScopeStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictScope>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(options, provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
diff --git a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
index 973eca85..db5a2db1 100644
--- a/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
+++ b/test/OpenIddict.EntityFrameworkCore.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
@@ -14,6 +14,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.EntityFrameworkCore.Models;
 using Xunit;
+using static OpenIddict.EntityFrameworkCore.OpenIddictTokenStoreResolver;
 
 namespace OpenIddict.EntityFrameworkCore.Tests
 {
@@ -28,7 +29,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -42,7 +43,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
 
             var options = Mock.Of<IOptionsMonitor<OpenIddictEntityFrameworkCoreOptions>>();
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
@@ -68,7 +69,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<OpenIddictToken>());
@@ -95,7 +96,7 @@ namespace OpenIddict.EntityFrameworkCore.Tests
                 });
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(options, provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), options, provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());
diff --git a/test/OpenIddict.NHibernate.Tests/OpenIddictNHibernateExtensionsTests.cs b/test/OpenIddict.NHibernate.Tests/OpenIddictNHibernateExtensionsTests.cs
index 76fd82c0..c65c9915 100644
--- a/test/OpenIddict.NHibernate.Tests/OpenIddictNHibernateExtensionsTests.cs
+++ b/test/OpenIddict.NHibernate.Tests/OpenIddictNHibernateExtensionsTests.cs
@@ -80,6 +80,25 @@ namespace OpenIddict.NHibernate.Tests
                                                  service.ImplementationType == implementationType);
         }
 
+        [Theory]
+        [InlineData(typeof(OpenIddictApplicationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictAuthorizationStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictScopeStoreResolver.TypeResolutionCache))]
+        [InlineData(typeof(OpenIddictTokenStoreResolver.TypeResolutionCache))]
+        public void UseEntityFramework_RegistersNHibernateStoreResolverCaches(Type type)
+        {
+            // Arrange
+            var services = new ServiceCollection();
+            var builder = new OpenIddictCoreBuilder(services);
+
+            // Act
+            builder.UseNHibernate();
+
+            // Assert
+            Assert.Contains(services, service => service.ServiceType == type &&
+                                                 service.ImplementationType == type);
+        }
+
         [Theory]
         [InlineData(typeof(OpenIddictApplicationStore<,,,>))]
         [InlineData(typeof(OpenIddictAuthorizationStore<,,,>))]
diff --git a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
index 0372021a..24a8f3ab 100644
--- a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
+++ b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictApplicationStoreResolverTests.cs
@@ -13,6 +13,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.NHibernate.Models;
 using Xunit;
+using static OpenIddict.NHibernate.OpenIddictApplicationStoreResolver;
 
 namespace OpenIddict.NHibernate.Tests
 {
@@ -26,7 +27,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(Mock.Of<IOpenIddictApplicationStore<CustomApplication>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomApplication>());
@@ -39,7 +40,7 @@ namespace OpenIddict.NHibernate.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomApplication>());
@@ -61,7 +62,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictApplicationStoreResolver(provider);
+            var resolver = new OpenIddictApplicationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyApplication>());
diff --git a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
index 1eb9b931..1d2a8ebc 100644
--- a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
+++ b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictAuthorizationStoreResolverTests.cs
@@ -13,6 +13,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.NHibernate.Models;
 using Xunit;
+using static OpenIddict.NHibernate.OpenIddictAuthorizationStoreResolver;
 
 namespace OpenIddict.NHibernate.Tests
 {
@@ -26,7 +27,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(Mock.Of<IOpenIddictAuthorizationStore<CustomAuthorization>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomAuthorization>());
@@ -39,7 +40,7 @@ namespace OpenIddict.NHibernate.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomAuthorization>());
@@ -61,7 +62,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictAuthorizationStoreResolver(provider);
+            var resolver = new OpenIddictAuthorizationStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyAuthorization>());
diff --git a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
index 812dd97e..1e66733a 100644
--- a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
+++ b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictScopeStoreResolverTests.cs
@@ -13,6 +13,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.NHibernate.Models;
 using Xunit;
+using static OpenIddict.NHibernate.OpenIddictScopeStoreResolver;
 
 namespace OpenIddict.NHibernate.Tests
 {
@@ -26,7 +27,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(Mock.Of<IOpenIddictScopeStore<CustomScope>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomScope>());
@@ -39,7 +40,7 @@ namespace OpenIddict.NHibernate.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomScope>());
@@ -61,7 +62,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictScopeStoreResolver(provider);
+            var resolver = new OpenIddictScopeStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyScope>());
diff --git a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
index f69f495c..23224184 100644
--- a/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
+++ b/test/OpenIddict.NHibernate.Tests/Resolvers/OpenIddictTokenStoreResolverTests.cs
@@ -13,6 +13,7 @@ using Moq;
 using OpenIddict.Abstractions;
 using OpenIddict.NHibernate.Models;
 using Xunit;
+using static OpenIddict.NHibernate.OpenIddictTokenStoreResolver;
 
 namespace OpenIddict.NHibernate.Tests
 {
@@ -26,7 +27,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(Mock.Of<IOpenIddictTokenStore<CustomToken>>());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<CustomToken>());
@@ -39,7 +40,7 @@ namespace OpenIddict.NHibernate.Tests
             var services = new ServiceCollection();
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             var exception = Assert.Throws<InvalidOperationException>(() => resolver.Get<CustomToken>());
@@ -61,7 +62,7 @@ namespace OpenIddict.NHibernate.Tests
             services.AddSingleton(CreateStore());
 
             var provider = services.BuildServiceProvider();
-            var resolver = new OpenIddictTokenStoreResolver(provider);
+            var resolver = new OpenIddictTokenStoreResolver(new TypeResolutionCache(), provider);
 
             // Act and assert
             Assert.NotNull(resolver.Get<MyToken>());