Use IServiceScopeFactory in some interceptors.

framework/src/Volo.Abp.Auditing/Volo/Abp/Auditing/AuditingInterceptor.cs

@@ -10,11 +10,11 @@ namespace Volo.Abp.Auditing
 {
     public class AuditingInterceptor : AbpInterceptor, ITransientDependency
     {
-        private readonly IServiceProvider _serviceProvider;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
 
-        public AuditingInterceptor(IServiceProvider serviceProvider)
+        public AuditingInterceptor(IServiceScopeFactory serviceScopeFactory)
         {
-            _serviceProvider = serviceProvider;
+            _serviceScopeFactory = serviceScopeFactory;
         }
 
         public override async Task InterceptAsync(IAbpMethodInvocation invocation)
@@ -57,28 +57,31 @@ namespace Volo.Abp.Auditing
                 return false;
             }
 
-            var auditingManager = _serviceProvider.GetRequiredService<IAuditingManager>();
+            using (var scope = _serviceScopeFactory.CreateScope())
-            var auditLogScope = auditingManager.Current;
-            if (auditLogScope == null)
             {
-                return false;
+                var auditingManager = scope.ServiceProvider.GetRequiredService<IAuditingManager>();
-            }
+                var auditLogScope = auditingManager.Current;
+                if (auditLogScope == null)
+                {
+                    return false;
+                }
 
-            var auditingHelper = _serviceProvider.GetRequiredService<IAuditingHelper>();
+                var auditingHelper = scope.ServiceProvider.GetRequiredService<IAuditingHelper>();
-            if (!auditingHelper.ShouldSaveAudit(invocation.Method))
+                if (!auditingHelper.ShouldSaveAudit(invocation.Method))
-            {
+                {
-                return false;
+                    return false;
-            }
+                }
 
-            auditLog = auditLogScope.Log;
+                auditLog = auditLogScope.Log;
-            auditLogAction = auditingHelper.CreateAuditLogAction(
+                auditLogAction = auditingHelper.CreateAuditLogAction(
-                auditLog,
+                    auditLog,
-                invocation.TargetObject.GetType(),
+                    invocation.TargetObject.GetType(),
-                invocation.Method,
+                    invocation.Method,
-                invocation.Arguments
+                    invocation.Arguments
-            );
+                );
 
-            return true;
+                return true;
+            }
         }
     }
 }

framework/src/Volo.Abp.Authorization/Volo/Abp/Authorization/AuthorizationInterceptor.cs

@@ -13,7 +13,7 @@ namespace Volo.Abp.Authorization
             _methodInvocationAuthorizationService = methodInvocationAuthorizationService;
         }
 
-        public async override Task InterceptAsync(IAbpMethodInvocation invocation)
+        public override async Task InterceptAsync(IAbpMethodInvocation invocation)
         {
             await AuthorizeAsync(invocation);
             await invocation.ProceedAsync();

framework/src/Volo.Abp.Features/Volo/Abp/Features/FeatureInterceptor.cs

@@ -9,11 +9,11 @@ namespace Volo.Abp.Features
 {
     public class FeatureInterceptor : AbpInterceptor, ITransientDependency
     {
-        private readonly IServiceProvider _serviceProvider;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
 
-        public FeatureInterceptor(IServiceProvider serviceProvider)
+        public FeatureInterceptor(IServiceScopeFactory serviceScopeFactory)
         {
-            _serviceProvider = serviceProvider;
+            _serviceScopeFactory = serviceScopeFactory;
         }
 
         public override async Task InterceptAsync(IAbpMethodInvocation invocation)
@@ -30,11 +30,14 @@ namespace Volo.Abp.Features
 
         protected virtual async Task CheckFeaturesAsync(IAbpMethodInvocation invocation)
         {
-            await _serviceProvider.GetRequiredService<IMethodInvocationFeatureCheckerService>().CheckAsync(
+            using (var scope = _serviceScopeFactory.CreateScope())
-                new MethodInvocationFeatureCheckerContext(
+            {
-                    invocation.Method
+                await scope.ServiceProvider.GetRequiredService<IMethodInvocationFeatureCheckerService>().CheckAsync(
-                )
+                    new MethodInvocationFeatureCheckerContext(
-            );
+                        invocation.Method
+                    )
+                );
+            }
         }
     }
 }

framework/src/Volo.Abp.Uow/Volo/Abp/Uow/UnitOfWorkInterceptor.cs

@@ -10,11 +10,11 @@ namespace Volo.Abp.Uow
 {
     public class UnitOfWorkInterceptor : AbpInterceptor, ITransientDependency
     {
-        private readonly IServiceProvider _serviceProvider;
+        private readonly IServiceScopeFactory _serviceScopeFactory;
 
-        public UnitOfWorkInterceptor(IServiceProvider serviceProvider)
+        public UnitOfWorkInterceptor(IServiceScopeFactory serviceScopeFactory)
         {
-            _serviceProvider = serviceProvider;
+            _serviceScopeFactory = serviceScopeFactory;
         }
 
         public override async Task InterceptAsync(IAbpMethodInvocation invocation)
@@ -25,24 +25,28 @@ namespace Volo.Abp.Uow
                 return;
             }
 
-            var options = CreateOptions(invocation, unitOfWorkAttribute);
+            using (var scope = _serviceScopeFactory.CreateScope())
-            var unitOfWorkManager = _serviceProvider.GetRequiredService<IUnitOfWorkManager>();
-
-            //Trying to begin a reserved UOW by AbpUnitOfWorkMiddleware
-            if (unitOfWorkManager.TryBeginReserved(UnitOfWork.UnitOfWorkReservationName, options))
             {
-                await invocation.ProceedAsync();
+                var options = CreateOptions(scope.ServiceProvider, invocation, unitOfWorkAttribute);
-                return;
-            }
 
-            using (var uow = unitOfWorkManager.Begin(options))
+                var unitOfWorkManager = scope.ServiceProvider.GetRequiredService<IUnitOfWorkManager>();
-            {
+
-                await invocation.ProceedAsync();
+                //Trying to begin a reserved UOW by AbpUnitOfWorkMiddleware
-                await uow.CompleteAsync();
+                if (unitOfWorkManager.TryBeginReserved(UnitOfWork.UnitOfWorkReservationName, options))
+                {
+                    await invocation.ProceedAsync();
+                    return;
+                }
+
+                using (var uow = unitOfWorkManager.Begin(options))
+                {
+                    await invocation.ProceedAsync();
+                    await uow.CompleteAsync();
+                }
             }
         }
 
-        private AbpUnitOfWorkOptions CreateOptions(IAbpMethodInvocation invocation, [CanBeNull] UnitOfWorkAttribute unitOfWorkAttribute)
+        private AbpUnitOfWorkOptions CreateOptions(IServiceProvider serviceProvider, IAbpMethodInvocation invocation, [CanBeNull] UnitOfWorkAttribute unitOfWorkAttribute)
         {
             var options = new AbpUnitOfWorkOptions();
 
@@ -50,9 +54,9 @@ namespace Volo.Abp.Uow
 
             if (unitOfWorkAttribute?.IsTransactional == null)
             {
-                var defaultOptions = _serviceProvider.GetRequiredService<IOptions<AbpUnitOfWorkDefaultOptions>>().Value;
+                var defaultOptions = serviceProvider.GetRequiredService<IOptions<AbpUnitOfWorkDefaultOptions>>().Value;
                 options.IsTransactional = defaultOptions.CalculateIsTransactional(
-                    autoValue: _serviceProvider.GetRequiredService<IUnitOfWorkTransactionBehaviourProvider>().IsTransactional
+                    autoValue: serviceProvider.GetRequiredService<IUnitOfWorkTransactionBehaviourProvider>().IsTransactional
                                ?? !invocation.Method.Name.StartsWith("Get", StringComparison.InvariantCultureIgnoreCase)
                 );
             }