Remove `IMapperAccessor`.

Resolve #14766

Register `IMapper` as transient, `MapperConfiguration` as `singleton`.

framework/src/Volo.Abp.AutoMapper/Volo/Abp/AutoMapper/AbpAutoMapperConfigurationContext.cs

@@ -6,6 +6,7 @@ namespace Volo.Abp.AutoMapper;
 public class AbpAutoMapperConfigurationContext : IAbpAutoMapperConfigurationContext
 {
     public IMapperConfigurationExpression MapperConfiguration { get; }
+
     public IServiceProvider ServiceProvider { get; }
 
     public AbpAutoMapperConfigurationContext(

framework/src/Volo.Abp.AutoMapper/Volo/Abp/AutoMapper/AbpAutoMapperModule.cs

@@ -26,45 +26,31 @@ public class AbpAutoMapperModule : AbpModule
     {
         context.Services.AddAutoMapperObjectMapper();
 
-        context.Services.AddSingleton<MapperAccessor>(CreateMappings);
-        context.Services.AddSingleton<IMapperAccessor>(provider => provider.GetRequiredService<MapperAccessor>());
-    }
-
-    private MapperAccessor CreateMappings(IServiceProvider serviceProvider)
-    {
-        using (var scope = serviceProvider.CreateScope())
+        context.Services.AddSingleton<IConfigurationProvider>(sp =>
         {
-            var options = scope.ServiceProvider.GetRequiredService<IOptions<AbpAutoMapperOptions>>().Value;
-
-            void ConfigureAll(IAbpAutoMapperConfigurationContext ctx)
+            using (var scope = sp.CreateScope())
             {
-                foreach (var configurator in options.Configurators)
+                var options = scope.ServiceProvider.GetRequiredService<IOptions<AbpAutoMapperOptions>>().Value;
+
+                var mapperConfiguration = new MapperConfiguration(mapperConfigurationExpression =>
                 {
-                    configurator(ctx);
-                }
-            }
+                    var autoMapperConfigurationContext = new AbpAutoMapperConfigurationContext(mapperConfigurationExpression, scope.ServiceProvider);
 
-            options.Configurators.Insert(0, ctx => ctx.MapperConfiguration.ConstructServicesUsing(serviceProvider.GetService));
+                    foreach (var configurator in options.Configurators)
+                    {
+                        configurator(autoMapperConfigurationContext);
+                    }
+                });
 
-            void ValidateAll(IConfigurationProvider config)
-            {
                 foreach (var profileType in options.ValidatingProfiles)
                 {
-                    config.Internal().AssertConfigurationIsValid(((Profile)Activator.CreateInstance(profileType)).ProfileName);
+                    mapperConfiguration.Internal().AssertConfigurationIsValid(((Profile)Activator.CreateInstance(profileType)).ProfileName);
                 }
-            }
-
-            var mapperConfiguration = new MapperConfiguration(mapperConfigurationExpression =>
-            {
-                ConfigureAll(new AbpAutoMapperConfigurationContext(mapperConfigurationExpression, scope.ServiceProvider));
-            });
 
-            ValidateAll(mapperConfiguration);
+                return mapperConfiguration;
+            }
+        });
 
-            return new MapperAccessor
-            {
-                Mapper = new Mapper(mapperConfiguration)
-            };
-        }
+        context.Services.AddTransient<IMapper>(sp => sp.GetRequiredService<IConfigurationProvider>().CreateMapper(sp.GetService));
     }
 }

framework/src/Volo.Abp.AutoMapper/Volo/Abp/AutoMapper/AutoMapperAutoObjectMappingProvider.cs

@@ -1,31 +1,37 @@
-using Volo.Abp.ObjectMapping;
+using System;
+using AutoMapper;
+using Volo.Abp.ObjectMapping;
 
 namespace Volo.Abp.AutoMapper;
 
 public class AutoMapperAutoObjectMappingProvider<TContext> : AutoMapperAutoObjectMappingProvider, IAutoObjectMappingProvider<TContext>
 {
-    public AutoMapperAutoObjectMappingProvider(IMapperAccessor mapperAccessor)
-        : base(mapperAccessor)
+    public AutoMapperAutoObjectMappingProvider(IMapper mapper)
+        : base(mapper)
     {
     }
 }
 
-public class AutoMapperAutoObjectMappingProvider : IAutoObjectMappingProvider
+public class AutoMapperAutoObjectMappingProvider : IAutoObjectMappingProvider, IDisposable
 {
-    public IMapperAccessor MapperAccessor { get; }
+    public IMapper Mapper { get; }
 
-    public AutoMapperAutoObjectMappingProvider(IMapperAccessor mapperAccessor)
+    public AutoMapperAutoObjectMappingProvider(IMapper mapper)
     {
-        MapperAccessor = mapperAccessor;
+        Mapper = mapper;
     }
 
     public virtual TDestination Map<TSource, TDestination>(object source)
     {
-        return MapperAccessor.Mapper.Map<TDestination>(source);
+        return Mapper.Map<TDestination>(source);
     }
 
     public virtual TDestination Map<TSource, TDestination>(TSource source, TDestination destination)
     {
-        return MapperAccessor.Mapper.Map(source, destination);
+        return Mapper.Map(source, destination);
+    }
+
+    public void Dispose()
+    {
     }
 }

framework/src/Volo.Abp.AutoMapper/Volo/Abp/AutoMapper/IMapperAccessor.cs

@@ -1,8 +0,0 @@
-using AutoMapper;
-
-namespace Volo.Abp.AutoMapper;
-
-public interface IMapperAccessor
-{
-    IMapper Mapper { get; }
-}

framework/src/Volo.Abp.AutoMapper/Volo/Abp/AutoMapper/MapperAccessor.cs

@@ -1,8 +0,0 @@
-using AutoMapper;
-
-namespace Volo.Abp.AutoMapper;
-
-internal class MapperAccessor : IMapperAccessor
-{
-    public IMapper Mapper { get; set; }
-}

framework/src/Volo.Abp.AutoMapper/Volo/Abp/ObjectMapping/AbpAutoMapperObjectMapperExtensions.cs

@@ -14,7 +14,7 @@ public static class AbpAutoMapperObjectMapperExtensions
     {
         if (autoObjectMappingProvider is AutoMapperAutoObjectMappingProvider autoMapperAutoObjectMappingProvider)
         {
-            return autoMapperAutoObjectMappingProvider.MapperAccessor.Mapper;
+            return autoMapperAutoObjectMappingProvider.Mapper;
         }
 
         throw new AbpException($"Given object is not an instance of {typeof(AutoMapperAutoObjectMappingProvider).AssemblyQualifiedName}. The type of the given object it {autoObjectMappingProvider.GetType().AssemblyQualifiedName}");

framework/test/Volo.Abp.AutoMapper.Tests/Volo/Abp/AutoMapper/AutoMapper_CustomServiceConstruction_Tests.cs

@@ -1,6 +1,7 @@
 using System;
 using AutoMapper;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Shouldly;
 using Volo.Abp.Modularity;
 using Volo.Abp.Testing;
@@ -25,6 +26,7 @@ public class AutoMapper_CustomServiceConstruction_Tests : AbpIntegratedTest<Auto
         {
             Name = nameof(SourceModel)
         };
+
         _objectMapper.Map<SourceModel, DestModel>(source).Name.ShouldBe(nameof(CustomMappingAction));
     }
 
@@ -33,6 +35,9 @@ public class AutoMapper_CustomServiceConstruction_Tests : AbpIntegratedTest<Auto
     {
         public override void ConfigureServices(ServiceConfigurationContext context)
         {
+            // Replace the build-in IMapper with a custom one to use ConstructServicesUsing.
+            context.Services.Replace(ServiceDescriptor.Transient<IMapper>(sp => sp.GetRequiredService<IConfigurationProvider>().CreateMapper()));
+
             Configure<AbpAutoMapperOptions>(options =>
             {
                 options.AddMaps<TestModule>();

framework/test/Volo.Abp.AutoMapper.Tests/Volo/Abp/AutoMapper/AutoMapper_Dependency_Injection_Tests.cs

@@ -1,4 +1,6 @@
-using AutoMapper;
+using System;
+using AutoMapper;
+using Microsoft.Extensions.DependencyInjection;
 using Shouldly;
 using Volo.Abp.DependencyInjection;
 using Volo.Abp.Testing;
@@ -9,13 +11,6 @@ namespace Volo.Abp.AutoMapper;
 
 public class AutoMapper_Dependency_Injection_Tests : AbpIntegratedTest<AutoMapperTestModule>
 {
-    private readonly IObjectMapper _objectMapper;
-
-    public AutoMapper_Dependency_Injection_Tests()
-    {
-        _objectMapper = GetRequiredService<IObjectMapper>();
-    }
-
     [Fact]
     public void Should_Registered_AutoMapper_Service()
     {
@@ -30,7 +25,12 @@ public class AutoMapper_Dependency_Injection_Tests : AbpIntegratedTest<AutoMappe
             Name = "Source"
         };
 
-        _objectMapper.Map<SourceModel, DestModel>(sourceModel).Name.ShouldBe(nameof(CustomMappingActionService));
+        using (var scope = ServiceProvider.CreateScope())
+        {
+            scope.ServiceProvider.GetRequiredService<IObjectMapper>().Map<SourceModel, DestModel>(sourceModel).Name.ShouldBe(nameof(CustomMappingActionService));
+        }
+
+        CustomMappingAction.IsDisposed.ShouldBeTrue();
     }
 
     public class SourceModel
@@ -51,8 +51,10 @@ public class AutoMapper_Dependency_Injection_Tests : AbpIntegratedTest<AutoMappe
         }
     }
 
-    public class CustomMappingAction : IMappingAction<SourceModel, DestModel>
+    public class CustomMappingAction : IMappingAction<SourceModel, DestModel>, IDisposable
     {
+        public static bool IsDisposed = false;
+
         private readonly CustomMappingActionService _customMappingActionService;
 
         public CustomMappingAction(CustomMappingActionService customMappingActionService)
@@ -64,6 +66,11 @@ public class AutoMapper_Dependency_Injection_Tests : AbpIntegratedTest<AutoMappe
         {
             destination.Name = _customMappingActionService.GetName();
         }
+
+        public void Dispose()
+        {
+            IsDisposed = true;
+        }
     }
 
     public class CustomMappingActionService : ITransientDependency