diff --git a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/GrpcJsonTranscodingServiceExtensions.cs b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/GrpcJsonTranscodingServiceExtensions.cs
index ceb7a2c0eb82..f9e5a7070d7c 100644
--- a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/GrpcJsonTranscodingServiceExtensions.cs
+++ b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/GrpcJsonTranscodingServiceExtensions.cs
@@ -4,6 +4,7 @@
 using Grpc.AspNetCore.Server;
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Shared;
+using Grpc.Shared.Server;
 using Microsoft.AspNetCore.Grpc.JsonTranscoding;
 using Microsoft.AspNetCore.Grpc.JsonTranscoding.Internal.Binding;
 using Microsoft.Extensions.DependencyInjection.Extensions;
@@ -28,6 +29,7 @@ public static IGrpcServerBuilder AddJsonTranscoding(this IGrpcServerBuilder buil
         builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton(typeof(IServiceMethodProvider<>), typeof(JsonTranscodingServiceMethodProvider<>)));
         builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<IConfigureOptions<GrpcJsonTranscodingOptions>, GrpcJsonTranscodingOptionsSetup>());
         builder.Services.TryAddSingleton<DescriptorRegistry>();
+        builder.Services.TryAddSingleton<InterceptorActivators>();
 
         return builder;
     }
diff --git a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingProviderServiceBinder.cs b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingProviderServiceBinder.cs
index ff55facbdd73..81325c33a82c 100644
--- a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingProviderServiceBinder.cs
+++ b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingProviderServiceBinder.cs
@@ -34,6 +34,7 @@ private delegate (RequestDelegate RequestDelegate, List<object> Metadata) Create
     private readonly GrpcServiceOptions<TService> _serviceOptions;
     private readonly IGrpcServiceActivator<TService> _serviceActivator;
     private readonly GrpcJsonTranscodingOptions _jsonTranscodingOptions;
+    private readonly InterceptorActivators _interceptorActivators;
     private readonly ILoggerFactory _loggerFactory;
     private readonly ILogger _logger;
 
@@ -45,7 +46,8 @@ internal JsonTranscodingProviderServiceBinder(
         GrpcServiceOptions<TService> serviceOptions,
         ILoggerFactory loggerFactory,
         IGrpcServiceActivator<TService> serviceActivator,
-        GrpcJsonTranscodingOptions jsonTranscodingOptions)
+        GrpcJsonTranscodingOptions jsonTranscodingOptions,
+        InterceptorActivators interceptorActivators)
     {
         _context = context;
         _invokerResolver = invokerResolver;
@@ -54,6 +56,7 @@ internal JsonTranscodingProviderServiceBinder(
         _serviceOptions = serviceOptions;
         _serviceActivator = serviceActivator;
         _jsonTranscodingOptions = jsonTranscodingOptions;
+        _interceptorActivators = interceptorActivators;
         _loggerFactory = loggerFactory;
         _logger = loggerFactory.CreateLogger<JsonTranscodingProviderServiceBinder<TService>>();
     }
@@ -162,7 +165,7 @@ private void ProcessHttpRule<TRequest, TResponse>(
             httpRule,
             methodDescriptor);
 
-        var methodInvoker = new UnaryServerMethodInvoker<TService, TRequest, TResponse>(invoker, method, methodOptions, _serviceActivator);
+        var methodInvoker = new UnaryServerMethodInvoker<TService, TRequest, TResponse>(invoker, method, methodOptions, _serviceActivator, _interceptorActivators);
         var callHandler = new UnaryServerCallHandler<TService, TRequest, TResponse>(
             methodInvoker,
             _loggerFactory,
@@ -189,7 +192,7 @@ private void ProcessHttpRule<TRequest, TResponse>(
             httpRule,
             methodDescriptor);
 
-        var methodInvoker = new ServerStreamingServerMethodInvoker<TService, TRequest, TResponse>(invoker, method, methodOptions, _serviceActivator);
+        var methodInvoker = new ServerStreamingServerMethodInvoker<TService, TRequest, TResponse>(invoker, method, methodOptions, _serviceActivator, _interceptorActivators);
         var callHandler = new ServerStreamingServerCallHandler<TService, TRequest, TResponse>(
             methodInvoker,
             _loggerFactory,
diff --git a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingServiceMethodProvider.cs b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingServiceMethodProvider.cs
index 66e03b25c1e5..4d46fb164b34 100644
--- a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingServiceMethodProvider.cs
+++ b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Internal/Binding/JsonTranscodingServiceMethodProvider.cs
@@ -20,6 +20,7 @@ internal sealed partial class JsonTranscodingServiceMethodProvider<TService> : I
     private readonly ILoggerFactory _loggerFactory;
     private readonly IGrpcServiceActivator<TService> _serviceActivator;
     private readonly DescriptorRegistry _serviceDescriptorRegistry;
+    private readonly InterceptorActivators _interceptorActivators;
 
     public JsonTranscodingServiceMethodProvider(
         ILoggerFactory loggerFactory,
@@ -27,7 +28,8 @@ public JsonTranscodingServiceMethodProvider(
         IOptions<GrpcServiceOptions<TService>> serviceOptions,
         IGrpcServiceActivator<TService> serviceActivator,
         IOptions<GrpcJsonTranscodingOptions> jsonTranscodingOptions,
-        DescriptorRegistry serviceDescriptorRegistry)
+        DescriptorRegistry serviceDescriptorRegistry,
+        InterceptorActivators interceptorActivators)
     {
         _logger = loggerFactory.CreateLogger<JsonTranscodingServiceMethodProvider<TService>>();
         _globalOptions = globalOptions.Value;
@@ -36,6 +38,7 @@ public JsonTranscodingServiceMethodProvider(
         _loggerFactory = loggerFactory;
         _serviceActivator = serviceActivator;
         _serviceDescriptorRegistry = serviceDescriptorRegistry;
+        _interceptorActivators = interceptorActivators;
     }
 
     public void OnServiceMethodDiscovery(ServiceMethodProviderContext<TService> context)
@@ -70,7 +73,8 @@ public void OnServiceMethodDiscovery(ServiceMethodProviderContext<TService> cont
                     _serviceOptions,
                     _loggerFactory,
                     _serviceActivator,
-                    _jsonTranscodingOptions);
+                    _jsonTranscodingOptions,
+                    _interceptorActivators);
 
                 try
                 {
diff --git a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Microsoft.AspNetCore.Grpc.JsonTranscoding.csproj b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Microsoft.AspNetCore.Grpc.JsonTranscoding.csproj
index cc8d435f5eeb..3e3332639fbf 100644
--- a/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Microsoft.AspNetCore.Grpc.JsonTranscoding.csproj
+++ b/src/Grpc/JsonTranscoding/src/Microsoft.AspNetCore.Grpc.JsonTranscoding/Microsoft.AspNetCore.Grpc.JsonTranscoding.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Description>HTTP API for gRPC ASP.NET Core</Description>
     <PackageTags>gRPC RPC HTTP/2 REST</PackageTags>
@@ -18,6 +18,8 @@
     <Compile Include="..\Shared\Server\ServerMethodInvokerBase.cs" Link="Internal\Shared\Server\ServerMethodInvokerBase.cs" />
     <Compile Include="..\Shared\Server\ServerStreamingServerMethodInvoker.cs" Link="Internal\Shared\Server\ServerStreamingServerMethodInvoker.cs" />
     <Compile Include="..\Shared\Server\UnaryServerMethodInvoker.cs" Link="Internal\Shared\Server\UnaryServerMethodInvoker.cs" />
+    <Compile Include="..\Shared\Server\ServerDynamicAccessConstants.cs" Link="Internal\Shared\Server\ServerDynamicAccessConstants.cs" />
+    <Compile Include="..\Shared\Server\InterceptorActivators.cs" Link="Internal\Shared\Server\InterceptorActivators.cs" />
     <Compile Include="..\Shared\DescriptorRegistry.cs" Link="Internal\Shared\DescriptorRegistry.cs" />
     <Compile Include="..\Shared\AuthContextHelpers.cs" Link="Internal\Shared\AuthContextHelpers.cs" />
     <Compile Include="..\Shared\ServiceDescriptorHelpers.cs" Link="Internal\Shared\ServiceDescriptorHelpers.cs" />
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/BindMethodFinder.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/BindMethodFinder.cs
index 4dbc6b8a470f..d48fdb90d61f 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/BindMethodFinder.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/BindMethodFinder.cs
@@ -16,6 +16,7 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using Grpc.Core;
 
@@ -64,6 +65,8 @@ internal static class BindMethodFinder
         return null;
     }
 
+    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2075:UnrecognizedReflectionPattern",
+        Justification = "Fallback doesn't have BindServiceMethodAttribute so can't be verified.")]
     internal static MethodInfo? GetBindMethodFallback(Type serviceType)
     {
         // Search for the generated service base class
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/ClientStreamingServerMethodInvoker.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/ClientStreamingServerMethodInvoker.cs
index 72377dc3b861..8e95adb7c3c1 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/ClientStreamingServerMethodInvoker.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/ClientStreamingServerMethodInvoker.cs
@@ -16,6 +16,7 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
 using Grpc.AspNetCore.Server;
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Core;
@@ -29,7 +30,7 @@ namespace Grpc.Shared.Server;
 /// <typeparam name="TService">Service type for this method.</typeparam>
 /// <typeparam name="TRequest">Request message type for this method.</typeparam>
 /// <typeparam name="TResponse">Response message type for this method.</typeparam>
-internal sealed class ClientStreamingServerMethodInvoker<TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
+internal sealed class ClientStreamingServerMethodInvoker<[DynamicallyAccessedMembers(ServerDynamicAccessConstants.ServiceAccessibility)] TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
     where TRequest : class
     where TResponse : class
     where TService : class
@@ -44,18 +45,20 @@ internal sealed class ClientStreamingServerMethodInvoker<TService, TRequest, TRe
     /// <param name="method">The description of the gRPC method.</param>
     /// <param name="options">The options used to execute the method.</param>
     /// <param name="serviceActivator">The service activator used to create service instances.</param>
+    /// <param name="interceptorActivators">The interceptor activators used to create interceptor instances.</param>
     public ClientStreamingServerMethodInvoker(
         ClientStreamingServerMethod<TService, TRequest, TResponse> invoker,
         Method<TRequest, TResponse> method,
         MethodOptions options,
-        IGrpcServiceActivator<TService> serviceActivator)
+        IGrpcServiceActivator<TService> serviceActivator,
+        InterceptorActivators interceptorActivators)
         : base(method, options, serviceActivator)
     {
         _invoker = invoker;
 
         if (Options.HasInterceptors)
         {
-            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors);
+            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors, interceptorActivators);
             _pipelineInvoker = interceptorPipeline.ClientStreamingPipeline(ResolvedInterceptorInvoker);
         }
     }
@@ -65,7 +68,7 @@ private async Task<TResponse> ResolvedInterceptorInvoker(IAsyncStreamReader<TReq
         GrpcActivatorHandle<TService> serviceHandle = default;
         try
         {
-            serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
+            serviceHandle = CreateServiceHandle(resolvedContext);
             return await _invoker(
                 serviceHandle.Instance,
                 requestStream,
@@ -95,7 +98,7 @@ public async Task<TResponse> Invoke(HttpContext httpContext, ServerCallContext s
             GrpcActivatorHandle<TService> serviceHandle = default;
             try
             {
-                serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
+                serviceHandle = CreateServiceHandle(httpContext);
                 return await _invoker(
                     serviceHandle.Instance,
                     requestStream,
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/DuplexStreamingServerMethodInvoker.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/DuplexStreamingServerMethodInvoker.cs
index 8a76507f9cce..4153d3fc6eea 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/DuplexStreamingServerMethodInvoker.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/DuplexStreamingServerMethodInvoker.cs
@@ -16,6 +16,7 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
 using Grpc.AspNetCore.Server;
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Core;
@@ -29,7 +30,7 @@ namespace Grpc.Shared.Server;
 /// <typeparam name="TService">Service type for this method.</typeparam>
 /// <typeparam name="TRequest">Request message type for this method.</typeparam>
 /// <typeparam name="TResponse">Response message type for this method.</typeparam>
-internal sealed class DuplexStreamingServerMethodInvoker<TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
+internal sealed class DuplexStreamingServerMethodInvoker<[DynamicallyAccessedMembers(ServerDynamicAccessConstants.ServiceAccessibility)] TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
     where TRequest : class
     where TResponse : class
     where TService : class
@@ -44,18 +45,20 @@ internal sealed class DuplexStreamingServerMethodInvoker<TService, TRequest, TRe
     /// <param name="method">The description of the gRPC method.</param>
     /// <param name="options">The options used to execute the method.</param>
     /// <param name="serviceActivator">The service activator used to create service instances.</param>
+    /// <param name="interceptorActivators">The interceptor activators used to create interceptor instances.</param>
     public DuplexStreamingServerMethodInvoker(
         DuplexStreamingServerMethod<TService, TRequest, TResponse> invoker,
         Method<TRequest, TResponse> method,
         MethodOptions options,
-        IGrpcServiceActivator<TService> serviceActivator)
+        IGrpcServiceActivator<TService> serviceActivator,
+        InterceptorActivators interceptorActivators)
         : base(method, options, serviceActivator)
     {
         _invoker = invoker;
 
         if (Options.HasInterceptors)
         {
-            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors);
+            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors, interceptorActivators);
             _pipelineInvoker = interceptorPipeline.DuplexStreamingPipeline(ResolvedInterceptorInvoker);
         }
     }
@@ -65,7 +68,7 @@ private async Task ResolvedInterceptorInvoker(IAsyncStreamReader<TRequest> reque
         GrpcActivatorHandle<TService> serviceHandle = default;
         try
         {
-            serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
+            serviceHandle = CreateServiceHandle(resolvedContext);
             await _invoker(
                 serviceHandle.Instance,
                 requestStream,
@@ -88,7 +91,7 @@ await _invoker(
     /// <param name="serverCallContext">The <see cref="ServerCallContext"/>.</param>
     /// <param name="requestStream">The <typeparamref name="TRequest"/> reader.</param>
     /// <param name="responseStream">The <typeparamref name="TResponse"/> writer.</param>
-    /// <returns>A <see cref="Task"/> that represents the asynchronous method.</returns>
+    /// <returns>A <see cref="Task{TResponse}"/> that represents the asynchronous method.</returns>
     public async Task Invoke(HttpContext httpContext, ServerCallContext serverCallContext, IAsyncStreamReader<TRequest> requestStream, IServerStreamWriter<TResponse> responseStream)
     {
         if (_pipelineInvoker == null)
@@ -96,7 +99,7 @@ public async Task Invoke(HttpContext httpContext, ServerCallContext serverCallCo
             GrpcActivatorHandle<TService> serviceHandle = default;
             try
             {
-                serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
+                serviceHandle = CreateServiceHandle(httpContext);
                 await _invoker(
                     serviceHandle.Instance,
                     requestStream,
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorActivators.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorActivators.cs
new file mode 100644
index 000000000000..b5e7ff82af98
--- /dev/null
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorActivators.cs
@@ -0,0 +1,49 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+using System.Collections.Concurrent;
+using System.Diagnostics.CodeAnalysis;
+using Grpc.AspNetCore.Server;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Grpc.Shared.Server;
+
+internal sealed class InterceptorActivators
+{
+    private readonly ConcurrentDictionary<Type, IGrpcInterceptorActivator> _cachedActivators = new();
+    private readonly IServiceProvider _serviceProvider;
+
+    public InterceptorActivators(IServiceProvider serviceProvider)
+    {
+        _serviceProvider = serviceProvider;
+    }
+
+    public IGrpcInterceptorActivator GetInterceptorActivator(Type type)
+    {
+        return _cachedActivators.GetOrAdd<IServiceProvider>(type, CreateActivator, _serviceProvider);
+    }
+
+    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
+        Justification = "Type parameter members are preserved with DynamicallyAccessedMembers on InterceptorRegistration.Type property.")]
+    [UnconditionalSuppressMessage("AotAnalysis", "IL3050:RequiresDynamicCode",
+        Justification = "Type definition is explicitly specified and type argument is always an Interceptor type.")]
+    private static IGrpcInterceptorActivator CreateActivator(Type type, IServiceProvider serviceProvider)
+    {
+        return (IGrpcInterceptorActivator)serviceProvider.GetRequiredService(typeof(IGrpcInterceptorActivator<>).MakeGenericType(type));
+    }
+}
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorPipelineBuilder.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorPipelineBuilder.cs
index ccea9f1ea554..4fb186f6dced 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorPipelineBuilder.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/InterceptorPipelineBuilder.cs
@@ -16,11 +16,9 @@
 
 #endregion
 
-using System.Linq;
 using Grpc.AspNetCore.Server;
 using Grpc.Core;
 using Grpc.Core.Interceptors;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Grpc.Shared.Server;
 
@@ -28,24 +26,26 @@ internal sealed class InterceptorPipelineBuilder<TRequest, TResponse>
     where TRequest : class
     where TResponse : class
 {
-    private readonly List<InterceptorActivatorHandle> _interceptors;
+    private readonly IReadOnlyList<InterceptorRegistration> _interceptors;
+    private readonly InterceptorActivators _interceptorActivators;
 
-    public InterceptorPipelineBuilder(IReadOnlyList<InterceptorRegistration> interceptors)
+    public InterceptorPipelineBuilder(IReadOnlyList<InterceptorRegistration> interceptors, InterceptorActivators interceptorActivators)
     {
-        _interceptors = interceptors.Select(i => new InterceptorActivatorHandle(i)).ToList();
+        _interceptors = interceptors;
+        _interceptorActivators = interceptorActivators;
     }
 
     public ClientStreamingServerMethod<TRequest, TResponse> ClientStreamingPipeline(ClientStreamingServerMethod<TRequest, TResponse> innerInvoker)
     {
         return BuildPipeline(innerInvoker, BuildInvoker);
 
-        static ClientStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorActivatorHandle interceptorActivatorHandle, ClientStreamingServerMethod<TRequest, TResponse> next)
+        static ClientStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorRegistration interceptorRegistration, InterceptorActivators interceptorActivators, ClientStreamingServerMethod<TRequest, TResponse> next)
         {
             return async (requestStream, context) =>
             {
                 var serviceProvider = context.GetHttpContext().RequestServices;
-                var interceptorActivator = interceptorActivatorHandle.GetActivator(serviceProvider);
-                var interceptorHandle = CreateInterceptor(interceptorActivatorHandle, interceptorActivator, serviceProvider);
+                var interceptorActivator = interceptorActivators.GetInterceptorActivator(interceptorRegistration.Type);
+                var interceptorHandle = CreateInterceptor(interceptorRegistration, interceptorActivator, serviceProvider);
 
                 try
                 {
@@ -63,13 +63,13 @@ internal DuplexStreamingServerMethod<TRequest, TResponse> DuplexStreamingPipelin
     {
         return BuildPipeline(innerInvoker, BuildInvoker);
 
-        static DuplexStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorActivatorHandle interceptorActivatorHandle, DuplexStreamingServerMethod<TRequest, TResponse> next)
+        static DuplexStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorRegistration interceptorRegistration, InterceptorActivators interceptorActivators, DuplexStreamingServerMethod<TRequest, TResponse> next)
         {
             return async (requestStream, responseStream, context) =>
             {
                 var serviceProvider = context.GetHttpContext().RequestServices;
-                var interceptorActivator = interceptorActivatorHandle.GetActivator(serviceProvider);
-                var interceptorHandle = CreateInterceptor(interceptorActivatorHandle, interceptorActivator, serviceProvider);
+                var interceptorActivator = interceptorActivators.GetInterceptorActivator(interceptorRegistration.Type);
+                var interceptorHandle = CreateInterceptor(interceptorRegistration, interceptorActivator, serviceProvider);
 
                 try
                 {
@@ -87,13 +87,18 @@ internal ServerStreamingServerMethod<TRequest, TResponse> ServerStreamingPipelin
     {
         return BuildPipeline(innerInvoker, BuildInvoker);
 
-        static ServerStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorActivatorHandle interceptorActivatorHandle, ServerStreamingServerMethod<TRequest, TResponse> next)
+        static ServerStreamingServerMethod<TRequest, TResponse> BuildInvoker(InterceptorRegistration interceptorRegistration, InterceptorActivators interceptorActivators, ServerStreamingServerMethod<TRequest, TResponse> next)
         {
             return async (request, responseStream, context) =>
             {
                 var serviceProvider = context.GetHttpContext().RequestServices;
-                var interceptorActivator = interceptorActivatorHandle.GetActivator(serviceProvider);
-                var interceptorHandle = CreateInterceptor(interceptorActivatorHandle, interceptorActivator, serviceProvider);
+                var interceptorActivator = interceptorActivators.GetInterceptorActivator(interceptorRegistration.Type);
+                var interceptorHandle = CreateInterceptor(interceptorRegistration, interceptorActivator, serviceProvider);
+
+                if (interceptorHandle.Instance == null)
+                {
+                    throw new InvalidOperationException($"Could not construct Interceptor instance for type {interceptorRegistration.Type.FullName}");
+                }
 
                 try
                 {
@@ -111,13 +116,13 @@ internal UnaryServerMethod<TRequest, TResponse> UnaryPipeline(UnaryServerMethod<
     {
         return BuildPipeline(innerInvoker, BuildInvoker);
 
-        static UnaryServerMethod<TRequest, TResponse> BuildInvoker(InterceptorActivatorHandle interceptorActivatorHandle, UnaryServerMethod<TRequest, TResponse> next)
+        static UnaryServerMethod<TRequest, TResponse> BuildInvoker(InterceptorRegistration interceptorRegistration, InterceptorActivators interceptorActivators, UnaryServerMethod<TRequest, TResponse> next)
         {
             return async (request, context) =>
             {
                 var serviceProvider = context.GetHttpContext().RequestServices;
-                var interceptorActivator = interceptorActivatorHandle.GetActivator(serviceProvider);
-                var interceptorHandle = CreateInterceptor(interceptorActivatorHandle, interceptorActivator, serviceProvider);
+                var interceptorActivator = interceptorActivators.GetInterceptorActivator(interceptorRegistration.Type);
+                var interceptorHandle = CreateInterceptor(interceptorRegistration, interceptorActivator, serviceProvider);
 
                 try
                 {
@@ -131,7 +136,7 @@ static UnaryServerMethod<TRequest, TResponse> BuildInvoker(InterceptorActivatorH
         }
     }
 
-    private T BuildPipeline<T>(T innerInvoker, Func<InterceptorActivatorHandle, T, T> wrapInvoker)
+    private T BuildPipeline<T>(T innerInvoker, Func<InterceptorRegistration, InterceptorActivators, T, T> wrapInvoker)
     {
         // The inner invoker will create the service instance and invoke the method
         var resolvedInvoker = innerInvoker;
@@ -139,48 +144,21 @@ private T BuildPipeline<T>(T innerInvoker, Func<InterceptorActivatorHandle, T, T
         // The list is reversed during construction so the first interceptor is built last and invoked first
         for (var i = _interceptors.Count - 1; i >= 0; i--)
         {
-            resolvedInvoker = wrapInvoker(_interceptors[i], resolvedInvoker);
+            resolvedInvoker = wrapInvoker(_interceptors[i], _interceptorActivators, resolvedInvoker);
         }
 
         return resolvedInvoker;
     }
 
-    private static GrpcActivatorHandle<Interceptor> CreateInterceptor(
-        InterceptorActivatorHandle interceptorActivatorHandle,
-        IGrpcInterceptorActivator interceptorActivator,
-        IServiceProvider serviceProvider)
+    private static GrpcActivatorHandle<Interceptor> CreateInterceptor(InterceptorRegistration interceptorRegistration, IGrpcInterceptorActivator interceptorActivator, IServiceProvider serviceProvider)
     {
-        var interceptorHandle = interceptorActivator.Create(serviceProvider, interceptorActivatorHandle.Registration);
+        var interceptorHandle = interceptorActivator.Create(serviceProvider, interceptorRegistration);
 
         if (interceptorHandle.Instance == null)
         {
-            throw new InvalidOperationException($"Could not construct Interceptor instance for type {interceptorActivatorHandle.Registration.Type.FullName}");
+            throw new InvalidOperationException($"Could not construct Interceptor instance for type {interceptorRegistration.Type.FullName}");
         }
 
         return interceptorHandle;
     }
-
-    private sealed class InterceptorActivatorHandle
-    {
-        public InterceptorRegistration Registration { get; }
-
-        private IGrpcInterceptorActivator? _interceptorActivator;
-
-        public InterceptorActivatorHandle(InterceptorRegistration interceptorRegistration)
-        {
-            Registration = interceptorRegistration;
-        }
-
-        public IGrpcInterceptorActivator GetActivator(IServiceProvider serviceProvider)
-        {
-            // Not thread safe. Side effect is resolving the service twice.
-            if (_interceptorActivator == null)
-            {
-                var activatorType = typeof(IGrpcInterceptorActivator<>).MakeGenericType(Registration.Type);
-                _interceptorActivator = (IGrpcInterceptorActivator)serviceProvider.GetRequiredService(activatorType);
-            }
-
-            return _interceptorActivator;
-        }
-    }
 }
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/MethodOptions.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/MethodOptions.cs
index 1fdf601659e7..58b83208dd36 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/MethodOptions.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/MethodOptions.cs
@@ -19,6 +19,7 @@
 using System.IO.Compression;
 using System.Linq;
 using Grpc.AspNetCore.Server;
+using Grpc.AspNetCore.Server.Internal;
 using Grpc.Net.Compression;
 
 namespace Grpc.Shared.Server;
@@ -70,6 +71,8 @@ internal sealed class MethodOptions
     // Fast check for whether the service has any interceptors
     internal bool HasInterceptors { get; }
 
+    internal bool SuppressCreatingService { get; }
+
     private MethodOptions(
         Dictionary<string, ICompressionProvider> compressionProviders,
         InterceptorCollection interceptors,
@@ -77,7 +80,8 @@ private MethodOptions(
         int? maxReceiveMessageSize,
         bool? enableDetailedErrors,
         string? responseCompressionAlgorithm,
-        CompressionLevel? responseCompressionLevel)
+        CompressionLevel? responseCompressionLevel,
+        bool suppressCreatingService)
     {
         CompressionProviders = compressionProviders;
         Interceptors = interceptors;
@@ -87,6 +91,7 @@ private MethodOptions(
         EnableDetailedErrors = enableDetailedErrors;
         ResponseCompressionAlgorithm = responseCompressionAlgorithm;
         ResponseCompressionLevel = responseCompressionLevel;
+        SuppressCreatingService = suppressCreatingService;
 
         if (ResponseCompressionAlgorithm != null)
         {
@@ -115,8 +120,9 @@ public static MethodOptions Create(IEnumerable<GrpcServiceOptions> serviceOption
         bool? enableDetailedErrors = null;
         string? responseCompressionAlgorithm = null;
         CompressionLevel? responseCompressionLevel = null;
+        bool? suppressCreatingService = null;
 
-        foreach (var options in Enumerable.Reverse(serviceOptions))
+        foreach (var options in serviceOptions.Reverse())
         {
             AddCompressionProviders(resolvedCompressionProviders, options.CompressionProviders);
             tempInterceptors.InsertRange(0, options.Interceptors);
@@ -128,9 +134,9 @@ public static MethodOptions Create(IEnumerable<GrpcServiceOptions> serviceOption
         }
 
         var interceptors = new InterceptorCollection();
-        foreach (var interceptor in tempInterceptors)
+        foreach (var registration in tempInterceptors)
         {
-            interceptors.Add(interceptor);
+            interceptors.Add(registration);
         }
 
         return new MethodOptions
@@ -141,7 +147,8 @@ public static MethodOptions Create(IEnumerable<GrpcServiceOptions> serviceOption
             maxReceiveMessageSize: maxReceiveMessageSize,
             enableDetailedErrors: enableDetailedErrors,
             responseCompressionAlgorithm: responseCompressionAlgorithm,
-            responseCompressionLevel: responseCompressionLevel
+            responseCompressionLevel: responseCompressionLevel,
+            suppressCreatingService: suppressCreatingService ?? false
         );
     }
 
@@ -151,10 +158,7 @@ private static void AddCompressionProviders(Dictionary<string, ICompressionProvi
         {
             foreach (var compressionProvider in compressionProviders)
             {
-                if (!resolvedProviders.ContainsKey(compressionProvider.EncodingName))
-                {
-                    resolvedProviders.Add(compressionProvider.EncodingName, compressionProvider);
-                }
+                resolvedProviders.TryAdd(compressionProvider.EncodingName, compressionProvider);
             }
         }
     }
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/ServerDynamicAccessConstants.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerDynamicAccessConstants.cs
new file mode 100644
index 000000000000..ec44fbd089dd
--- /dev/null
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerDynamicAccessConstants.cs
@@ -0,0 +1,26 @@
+#region Copyright notice and license
+
+// Copyright 2019 The gRPC Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#endregion
+
+using System.Diagnostics.CodeAnalysis;
+
+namespace Grpc.Shared.Server;
+
+internal static class ServerDynamicAccessConstants
+{
+    internal const DynamicallyAccessedMemberTypes ServiceAccessibility = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods;
+}
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/ServerMethodInvokerBase.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerMethodInvokerBase.cs
index 8e61c5877e38..c599b6dad958 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/ServerMethodInvokerBase.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerMethodInvokerBase.cs
@@ -16,8 +16,10 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
 using Grpc.AspNetCore.Server;
 using Grpc.Core;
+using Microsoft.AspNetCore.Http;
 
 namespace Grpc.Shared.Server;
 
@@ -27,7 +29,7 @@ namespace Grpc.Shared.Server;
 /// <typeparam name="TService">Service type for this method.</typeparam>
 /// <typeparam name="TRequest">Request message type for this method.</typeparam>
 /// <typeparam name="TResponse">Response message type for this method.</typeparam>
-internal abstract class ServerMethodInvokerBase<TService, TRequest, TResponse>
+internal abstract class ServerMethodInvokerBase<[DynamicallyAccessedMembers(ServerDynamicAccessConstants.ServiceAccessibility)] TService, TRequest, TResponse>
     where TRequest : class
     where TResponse : class
     where TService : class
@@ -62,4 +64,19 @@ private protected ServerMethodInvokerBase(
         Options = options;
         ServiceActivator = serviceActivator;
     }
+
+    protected GrpcActivatorHandle<TService> CreateServiceHandle(ServerCallContext context)
+    {
+        return CreateServiceHandle(context.GetHttpContext());
+    }
+
+    protected GrpcActivatorHandle<TService> CreateServiceHandle(HttpContext httpContext)
+    {
+        if (!Options.SuppressCreatingService)
+        {
+            return ServiceActivator.Create(httpContext.RequestServices);
+        }
+
+        return default;
+    }
 }
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/ServerStreamingServerMethodInvoker.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerStreamingServerMethodInvoker.cs
index 5b73c4b22309..a29aabfb6e80 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/ServerStreamingServerMethodInvoker.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/ServerStreamingServerMethodInvoker.cs
@@ -16,6 +16,7 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
 using Grpc.AspNetCore.Server;
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Core;
@@ -29,7 +30,7 @@ namespace Grpc.Shared.Server;
 /// <typeparam name="TService">Service type for this method.</typeparam>
 /// <typeparam name="TRequest">Request message type for this method.</typeparam>
 /// <typeparam name="TResponse">Response message type for this method.</typeparam>
-internal sealed class ServerStreamingServerMethodInvoker<TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
+internal sealed class ServerStreamingServerMethodInvoker<[DynamicallyAccessedMembers(ServerDynamicAccessConstants.ServiceAccessibility)] TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
     where TRequest : class
     where TResponse : class
     where TService : class
@@ -44,18 +45,20 @@ internal sealed class ServerStreamingServerMethodInvoker<TService, TRequest, TRe
     /// <param name="method">The description of the gRPC method.</param>
     /// <param name="options">The options used to execute the method.</param>
     /// <param name="serviceActivator">The service activator used to create service instances.</param>
+    /// <param name="interceptorActivators">The interceptor activators used to create interceptor instances.</param>
     public ServerStreamingServerMethodInvoker(
         ServerStreamingServerMethod<TService, TRequest, TResponse> invoker,
         Method<TRequest, TResponse> method,
         MethodOptions options,
-        IGrpcServiceActivator<TService> serviceActivator)
+        IGrpcServiceActivator<TService> serviceActivator,
+        InterceptorActivators interceptorActivators)
         : base(method, options, serviceActivator)
     {
         _invoker = invoker;
 
         if (Options.HasInterceptors)
         {
-            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors);
+            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors, interceptorActivators);
             _pipelineInvoker = interceptorPipeline.ServerStreamingPipeline(ResolvedInterceptorInvoker);
         }
     }
@@ -65,7 +68,7 @@ private async Task ResolvedInterceptorInvoker(TRequest request, IServerStreamWri
         GrpcActivatorHandle<TService> serviceHandle = default;
         try
         {
-            serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
+            serviceHandle = CreateServiceHandle(resolvedContext);
             await _invoker(
                 serviceHandle.Instance,
                 request,
@@ -96,7 +99,7 @@ public async Task Invoke(HttpContext httpContext, ServerCallContext serverCallCo
             GrpcActivatorHandle<TService> serviceHandle = default;
             try
             {
-                serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
+                serviceHandle = CreateServiceHandle(httpContext);
                 await _invoker(
                     serviceHandle.Instance,
                     request,
diff --git a/src/Grpc/JsonTranscoding/src/Shared/Server/UnaryServerMethodInvoker.cs b/src/Grpc/JsonTranscoding/src/Shared/Server/UnaryServerMethodInvoker.cs
index b29f08c94f5c..09398689ccb0 100644
--- a/src/Grpc/JsonTranscoding/src/Shared/Server/UnaryServerMethodInvoker.cs
+++ b/src/Grpc/JsonTranscoding/src/Shared/Server/UnaryServerMethodInvoker.cs
@@ -16,6 +16,8 @@
 
 #endregion
 
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.ExceptionServices;
 using Grpc.AspNetCore.Server;
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Core;
@@ -29,7 +31,7 @@ namespace Grpc.Shared.Server;
 /// <typeparam name="TService">Service type for this method.</typeparam>
 /// <typeparam name="TRequest">Request message type for this method.</typeparam>
 /// <typeparam name="TResponse">Response message type for this method.</typeparam>
-internal sealed class UnaryServerMethodInvoker<TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
+internal sealed class UnaryServerMethodInvoker<[DynamicallyAccessedMembers(ServerDynamicAccessConstants.ServiceAccessibility)] TService, TRequest, TResponse> : ServerMethodInvokerBase<TService, TRequest, TResponse>
     where TRequest : class
     where TResponse : class
     where TService : class
@@ -44,18 +46,20 @@ internal sealed class UnaryServerMethodInvoker<TService, TRequest, TResponse> :
     /// <param name="method">The description of the gRPC method.</param>
     /// <param name="options">The options used to execute the method.</param>
     /// <param name="serviceActivator">The service activator used to create service instances.</param>
+    /// <param name="interceptorActivators">The interceptor activators used to create interceptor instances.</param>
     public UnaryServerMethodInvoker(
         UnaryServerMethod<TService, TRequest, TResponse> invoker,
         Method<TRequest, TResponse> method,
         MethodOptions options,
-        IGrpcServiceActivator<TService> serviceActivator)
+        IGrpcServiceActivator<TService> serviceActivator,
+        InterceptorActivators interceptorActivators)
         : base(method, options, serviceActivator)
     {
         _invoker = invoker;
 
         if (Options.HasInterceptors)
         {
-            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors);
+            var interceptorPipeline = new InterceptorPipelineBuilder<TRequest, TResponse>(Options.Interceptors, interceptorActivators);
             _pipelineInvoker = interceptorPipeline.UnaryPipeline(ResolvedInterceptorInvoker);
         }
     }
@@ -65,7 +69,7 @@ private async Task<TResponse> ResolvedInterceptorInvoker(TRequest resolvedReques
         GrpcActivatorHandle<TService> serviceHandle = default;
         try
         {
-            serviceHandle = ServiceActivator.Create(resolvedContext.GetHttpContext().RequestServices);
+            serviceHandle = CreateServiceHandle(resolvedContext);
             return await _invoker(serviceHandle.Instance, resolvedRequest, resolvedContext);
         }
         finally
@@ -85,32 +89,88 @@ private async Task<TResponse> ResolvedInterceptorInvoker(TRequest resolvedReques
     /// <param name="request">The <typeparamref name="TRequest"/> message.</param>
     /// <returns>A <see cref="Task{TResponse}"/> that represents the asynchronous method. The <see cref="Task{TResponse}.Result"/>
     /// property returns the <typeparamref name="TResponse"/> message.</returns>
-    public async Task<TResponse> Invoke(HttpContext httpContext, ServerCallContext serverCallContext, TRequest request)
+    public Task<TResponse> Invoke(HttpContext httpContext, ServerCallContext serverCallContext, TRequest request)
     {
         if (_pipelineInvoker == null)
         {
             GrpcActivatorHandle<TService> serviceHandle = default;
+            Task<TResponse>? invokerTask = null;
             try
             {
-                serviceHandle = ServiceActivator.Create(httpContext.RequestServices);
-                return await _invoker(
+                serviceHandle = CreateServiceHandle(httpContext);
+                invokerTask = _invoker(
                     serviceHandle.Instance,
                     request,
                     serverCallContext);
             }
-            finally
+            catch (Exception ex)
             {
+                // Invoker calls user code. User code may throw an exception instead
+                // of a faulted task. We need to catch the exception, ensure cleanup
+                // runs and convert exception into a faulted task.
                 if (serviceHandle.Instance != null)
                 {
-                    await ServiceActivator.ReleaseAsync(serviceHandle);
+                    var releaseTask = ServiceActivator.ReleaseAsync(serviceHandle);
+                    if (!releaseTask.IsCompletedSuccessfully)
+                    {
+                        // Capture the current exception state so we can rethrow it after awaiting
+                        // with the same stack trace.
+                        var exceptionDispatchInfo = ExceptionDispatchInfo.Capture(ex);
+                        return AwaitServiceReleaseAndThrow(releaseTask, exceptionDispatchInfo);
+                    }
                 }
+
+                return Task.FromException<TResponse>(ex);
+            }
+
+            if (invokerTask.IsCompletedSuccessfully && serviceHandle.Instance != null)
+            {
+                var releaseTask = ServiceActivator.ReleaseAsync(serviceHandle);
+                if (!releaseTask.IsCompletedSuccessfully)
+                {
+                    return AwaitServiceReleaseAndReturn(invokerTask.Result, serviceHandle);
+                }
+
+                return invokerTask;
             }
+
+            return AwaitInvoker(invokerTask, serviceHandle);
         }
         else
         {
-            return await _pipelineInvoker(
+            return _pipelineInvoker(
                 request,
                 serverCallContext);
         }
     }
+
+    private async Task<TResponse> AwaitInvoker(Task<TResponse> invokerTask, GrpcActivatorHandle<TService> serviceHandle)
+    {
+        try
+        {
+            return await invokerTask;
+        }
+        finally
+        {
+            if (serviceHandle.Instance != null)
+            {
+                await ServiceActivator.ReleaseAsync(serviceHandle);
+            }
+        }
+    }
+
+    private static async Task<TResponse> AwaitServiceReleaseAndThrow(ValueTask releaseTask, ExceptionDispatchInfo ex)
+    {
+        await releaseTask;
+        ex.Throw();
+
+        // Should never reach here
+        return null;
+    }
+
+    private async Task<TResponse> AwaitServiceReleaseAndReturn(TResponse invokerResult, GrpcActivatorHandle<TService> serviceHandle)
+    {
+        await ServiceActivator.ReleaseAsync(serviceHandle);
+        return invokerResult;
+    }
 }
diff --git a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.IntegrationTests/Infrastructure/DynamicGrpcServiceRegistry.cs b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.IntegrationTests/Infrastructure/DynamicGrpcServiceRegistry.cs
index dc86e1303a5e..200977c57185 100644
--- a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.IntegrationTests/Infrastructure/DynamicGrpcServiceRegistry.cs
+++ b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.IntegrationTests/Infrastructure/DynamicGrpcServiceRegistry.cs
@@ -8,6 +8,7 @@
 using Grpc.AspNetCore.Server.Model;
 using Grpc.Core;
 using Grpc.Shared;
+using Grpc.Shared.Server;
 using IntegrationTestsWebsite.Infrastructure;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Grpc.JsonTranscoding.Internal.Binding;
@@ -151,7 +152,8 @@ private JsonTranscodingProviderServiceBinder<DynamicService> CreateJsonTranscodi
             _serviceProvider.GetRequiredService<IOptions<GrpcServiceOptions<DynamicService>>>().Value,
             _serviceProvider.GetRequiredService<ILoggerFactory>(),
             _serviceProvider.GetRequiredService<IGrpcServiceActivator<DynamicService>>(),
-            JsonTranscodingOptions);
+            JsonTranscodingOptions,
+            new InterceptorActivators(_serviceProvider));
 
         return binder;
     }
diff --git a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/Infrastructure/TestHelpers.cs b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/Infrastructure/TestHelpers.cs
index 656420605d4e..7bdbfe24b6be 100644
--- a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/Infrastructure/TestHelpers.cs
+++ b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/Infrastructure/TestHelpers.cs
@@ -19,10 +19,7 @@ internal static class TestHelpers
 {
     public static DefaultHttpContext CreateHttpContext(CancellationToken cancellationToken = default, Stream? bodyStream = null)
     {
-        var serviceCollection = new ServiceCollection();
-        serviceCollection.AddSingleton<JsonTranscodingGreeterService>();
-        serviceCollection.AddSingleton(typeof(IGrpcInterceptorActivator<>), typeof(TestInterceptorActivator<>));
-        var serviceProvider = serviceCollection.BuildServiceProvider();
+        var serviceProvider = CreateServiceProvider();
         var httpContext = new DefaultHttpContext();
         httpContext.Request.Host = new HostString("localhost");
         httpContext.RequestServices = serviceProvider;
@@ -32,6 +29,15 @@ public static DefaultHttpContext CreateHttpContext(CancellationToken cancellatio
         return httpContext;
     }
 
+    public static IServiceProvider CreateServiceProvider()
+    {
+        var serviceCollection = new ServiceCollection();
+        serviceCollection.AddSingleton<JsonTranscodingGreeterService>();
+        serviceCollection.AddSingleton(typeof(IGrpcInterceptorActivator<>), typeof(TestInterceptorActivator<>));
+        var serviceProvider = serviceCollection.BuildServiceProvider();
+        return serviceProvider;
+    }
+
     internal static MessageDescriptor GetMessageDescriptor(Type typeToConvert)
     {
         var property = typeToConvert.GetProperty("Descriptor", BindingFlags.Static | BindingFlags.Public, binder: null, typeof(MessageDescriptor), Type.EmptyTypes, modifiers: null);
diff --git a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/ServerStreamingServerCallHandlerTests.cs b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/ServerStreamingServerCallHandlerTests.cs
index f74675a6b9a4..ec1f3666d737 100644
--- a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/ServerStreamingServerCallHandlerTests.cs
+++ b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/ServerStreamingServerCallHandlerTests.cs
@@ -20,6 +20,7 @@
 using Microsoft.AspNetCore.Grpc.JsonTranscoding.Internal.Json;
 using Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests.Infrastructure;
 using Microsoft.AspNetCore.InternalTesting;
+using Microsoft.Extensions.DependencyInjection;
 using Transcoding;
 using Xunit.Abstractions;
 using MethodOptions = Grpc.Shared.Server.MethodOptions;
@@ -339,7 +340,8 @@ private ServerStreamingServerCallHandler<JsonTranscodingGreeterService, TRequest
             invoker,
             method,
             MethodOptions.Create(new[] { serviceOptions }),
-            new TestGrpcServiceActivator<JsonTranscodingGreeterService>());
+            new TestGrpcServiceActivator<JsonTranscodingGreeterService>(),
+            new InterceptorActivators(TestHelpers.CreateServiceProvider()));
 
         var jsonSettings = jsonTranscodingOptions?.JsonSettings ?? new GrpcJsonSettings() { WriteIndented = false };
 
diff --git a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/UnaryServerCallHandlerTests.cs b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/UnaryServerCallHandlerTests.cs
index 1d6ad6ba4c38..762483117ba4 100644
--- a/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/UnaryServerCallHandlerTests.cs
+++ b/src/Grpc/JsonTranscoding/test/Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests/UnaryServerCallHandlerTests.cs
@@ -23,6 +23,7 @@
 using Microsoft.AspNetCore.Grpc.JsonTranscoding.Tests.Infrastructure;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.InternalTesting;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Primitives;
 using Transcoding;
 using Xunit.Abstractions;
@@ -1842,7 +1843,8 @@ private UnaryServerCallHandler<JsonTranscodingGreeterService, TRequest, TRespons
             invoker,
             method,
             MethodOptions.Create(new[] { serviceOptions }),
-            new TestGrpcServiceActivator<JsonTranscodingGreeterService>());
+            new TestGrpcServiceActivator<JsonTranscodingGreeterService>(),
+            new InterceptorActivators(TestHelpers.CreateServiceProvider()));
 
         var descriptorRegistry = new DescriptorRegistry();
         descriptorRegistry.RegisterFileDescriptor(TestHelpers.GetMessageDescriptor(typeof(TRequest)).File);