Adding support for DI-enabled destination factories.

docs/source/Construction.md

@@ -53,4 +53,79 @@ You can configure which constructors are considered for the destination object:
 // use only public constructors
 var configuration = new MapperConfiguration(cfg => cfg.ShouldUseConstructor = constructor => constructor.IsPublic, loggerFactory);
 ```
-When mapping to records, consider using only public constructors.
+When mapping to records, consider using only public constructors.
+
+## Class-Based Destination Factories
+
+Instead of automatic constructor matching or inline `ConstructUsing` lambdas, you can implement custom constructor logic as a class. This enables reuse across multiple mappings and supports dependency injection.
+
+This is different than `ConvertUsing` which replaces the entire mapping operation.
+
+### Interface
+
+`IDestinationFactory<TSource, TDestination>` is used to implement custom object construction:
+
+```csharp
+public interface IDestinationFactory<in TSource, out TDestination>
+{
+    TDestination Construct(TSource source, ResolutionContext context);
+}
+```
+
+### Usage
+
+```csharp
+public class CustomConstructor : IDestinationFactory<Source, Destination>
+{
+    public Destination Construct(Source source, ResolutionContext context)
+    {
+        // Custom instantiation logic
+        return new Destination { InitialValue = source.Value * 2 };
+    }
+}
+
+cfg.CreateMap<Source, Destination>()
+    .ConstructUsing<CustomConstructor>();
+```
+
+### Dependency Injection
+
+Destination factories are resolved from the DI container, enabling constructor injection of services:
+
+```csharp
+public class DIAwareConstructor : IDestinationFactory<Source, Destination>
+{
+    private readonly IMyService _service;
+
+    public DIAwareConstructor(IMyService service)
+    {
+        _service = service;
+    }
+
+    public Destination Construct(Source source, ResolutionContext context)
+    {
+        return new Destination 
+        { 
+            InitialValue = _service.CalculateValue(source.Value) 
+        };
+    }
+}
+
+// Registration
+services.AddScoped<IMyService, MyService>();
+services.AddAutoMapper(cfg =>
+{
+    cfg.CreateMap<Source, Destination>()
+        .ConstructUsing<DIAwareConstructor>();
+});
+```
+
+Constructor instances are resolved at mapper configuration time and cached in the compiled expression, so DI resolution does not occur during individual mapping calls.
+
+For runtime type resolution, use the non-generic overload:
+
+```csharp
+cfg.CreateMap(typeof(Source), typeof(Destination))
+    .ConstructUsing(typeof(CustomConstructor));
+```
+

docs/source/Dependency-injection.md

@@ -55,55 +55,11 @@ When using `AddAutoMapper`, AutoMapper will automatically register implementatio
 - `IMemberValueResolver<TSource, TDestination, TSourceMember, TDestMember>`
 - `ITypeConverter<TSource, TDestination>`
 - `IValueConverter<TSourceMember, TDestinationMember>`
+- `IDestinationFactory<TSource, TDestination>`
 - `ICondition<TSource, TDestination, TMember>`
 - `IPreCondition<TSource, TDestination>`
 - `IMappingAction<TSource, TDestination>`
 
-This allows you to use class-based conditions with dependency injection:
-
-```c#
-public class MyCondition : ICondition<Source, Destination, int>
-{
-    private readonly IMyService _myService;
-
-    public MyCondition(IMyService myService)
-    {
-        _myService = myService;
-    }
-
-    public bool Evaluate(Source source, Destination destination, int sourceMember, 
-                        int destMember, ResolutionContext context)
-    {
-        return _myService.ShouldMap(sourceMember);
-    }
-}
-
-public class ConditionProfile : Profile
-{
-    public ConditionProfile()
-    {
-        CreateMap<Source, Destination>()
-            .ForMember(d => d.Value, o =>
-            {
-                o.Condition<MyCondition>();
-                o.MapFrom(s => s.Value);
-            });
-    }
-}
-
-// In Startup.cs / Program.cs:
-services.AddTransient<IMyService, MyService>();
-services.AddAutoMapper(cfg => { }, typeof(ConditionProfile).Assembly);
-```
-
-Or dynamic service location, to be used in the case of instance-based containers (including child/nested containers):
-
-```c#
-var mapper = new Mapper(configuration, childContainer.GetInstance);
-
-var dest = mapper.Map<Source, Destination>(new Source { Value = 15 });
-```
-
 ## Queryable Extensions
 
 Starting with 8.0 you can use `IMapper.ProjectTo`. For older versions you need to pass the configuration to the extension method ``` IQueryable.ProjectTo<T>(IConfigurationProvider) ```.

src/AutoMapper.DI.Tests/AppDomainResolutionTests.cs

@@ -30,7 +30,7 @@ public void ShouldResolveConfiguration()
         [Fact]
         public void ShouldConfigureProfiles()
         {
-            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(5);
+            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(6);
         }
 
         [Fact]

src/AutoMapper.DI.Tests/AssemblyResolutionTests.cs

@@ -37,7 +37,7 @@ public void ShouldResolveConfiguration()
         [Fact]
         public void ShouldConfigureProfiles()
         {
-            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(5);
+            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(6);
         }
 
         [Fact]

src/AutoMapper.DI.Tests/DependencyTests.cs

@@ -77,4 +77,42 @@ public void ShouldSkipMappingWithDependency_WhenConditionFails()
             dest.Value.ShouldBe(0);
         }
     }
+
+    public class DestinationFactoryDependencyTests
+    {
+        private readonly IServiceProvider _provider;
+
+        public DestinationFactoryDependencyTests()
+        {
+            IServiceCollection services = new ServiceCollection();
+            services.AddTransient<ISomeService>(sp => new FooService(5));
+            services.AddSingleton<ILoggerFactory>(NullLoggerFactory.Instance);
+            services.AddAutoMapper(_ => { }, typeof(FactorySource));
+            _provider = services.BuildServiceProvider();
+
+            _provider.GetService<IConfigurationProvider>().AssertConfigurationIsValid();
+        }
+
+        [Fact]
+        public void ShouldConstructWithDependency()
+        {
+            var mapper = _provider.GetService<IMapper>();
+            var dest = mapper.Map<FactorySource, FactoryDest>(new FactorySource { Value = 10 });
+
+            // FooService.Modify(10) = 10 + 5 = 15
+            dest.InitialValue.ShouldBe(15);
+            dest.Value.ShouldBe(10);
+        }
+
+        [Fact]
+        public void ShouldConstructWithDependency_DifferentValue()
+        {
+            var mapper = _provider.GetService<IMapper>();
+            var dest = mapper.Map<FactorySource, FactoryDest>(new FactorySource { Value = 20 });
+
+            // FooService.Modify(20) = 20 + 5 = 25
+            dest.InitialValue.ShouldBe(25);
+            dest.Value.ShouldBe(20);
+        }
+    }
 }

src/AutoMapper.DI.Tests/Profiles.cs

@@ -183,4 +183,35 @@ public ConditionProfile()
                 });
         }
     }
+
+    public class FactorySource
+    {
+        public int Value { get; set; }
+    }
+
+    public class FactoryDest
+    {
+        public int Value { get; set; }
+        public int InitialValue { get; set; }
+    }
+
+    public class DependencyFactory : IDestinationFactory<FactorySource, FactoryDest>
+    {
+        private readonly ISomeService _service;
+
+        public DependencyFactory(ISomeService service) => _service = service;
+
+        public FactoryDest Construct(FactorySource source, ResolutionContext context)
+            => new FactoryDest { InitialValue = _service.Modify(source.Value) };
+    }
+
+    internal class FactoryProfile : Profile
+    {
+        public FactoryProfile()
+        {
+            CreateMap<FactorySource, FactoryDest>()
+                .ConstructUsing<DependencyFactory>()
+                .ForMember(dest => dest.InitialValue, opt => opt.Ignore());
+        }
+    }
 }

src/AutoMapper.DI.Tests/TypeResolutionTests.cs

@@ -33,7 +33,7 @@ public void ShouldResolveConfiguration()
         [Fact]
         public void ShouldConfigureProfiles()
         {
-            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(5);
+            _provider.GetService<IConfigurationProvider>().Internal().GetAllTypeMaps().Count.ShouldBe(6);
         }
 
         [Fact]

src/AutoMapper/Configuration/IMappingExpressionBase.cs

@@ -157,6 +157,20 @@ public interface IMappingExpressionBase<TSource, TDestination, out TMappingExpre
     /// <returns>Itself</returns>
     TMappingExpression ConstructUsing(Func<TSource, ResolutionContext, TDestination> ctor);
     /// <summary>
+    /// Supply a custom object constructor type for instantiating the destination type with dependency injection support
+    /// </summary>
+    /// <remarks>Not used for LINQ projection (ProjectTo). Constructor is resolved from the DI container at configuration time.</remarks>
+    /// <typeparam name="TConstructor">Constructor type implementing IDestinationFactory&lt;TSource, TDestination&gt;</typeparam>
+    /// <returns>Itself</returns>
+    TMappingExpression ConstructUsing<TConstructor>() where TConstructor : IDestinationFactory<TSource, TDestination>;
+    /// <summary>
+    /// Supply a custom object constructor type for instantiating the destination type with dependency injection support.
+    /// Used when the constructor type is not known at compile-time.
+    /// </summary>
+    /// <remarks>Not used for LINQ projection (ProjectTo). Constructor is resolved from the DI container at configuration time.</remarks>
+    /// <param name="objectConstructorType">Constructor type implementing IDestinationFactory</param>
+    void ConstructUsing(Type objectConstructorType);
+    /// <summary>
     /// Override the destination type mapping for looking up configuration and instantiation
     /// </summary>
     /// <param name="typeOverride"></param>
@@ -197,6 +211,22 @@ public interface IMappingExpressionBase<TSource, TDestination, out TMappingExpre
     /// <typeparam name="TTypeConverter">Type converter type</typeparam>
     void ConvertUsing<TTypeConverter>() where TTypeConverter : ITypeConverter<TSource, TDestination>;
 }
+
+/// <summary>
+/// Custom destination factory for instantiating destination objects with dependency injection support.
+/// </summary>
+/// <typeparam name="TSource">Source type</typeparam>
+/// <typeparam name="TDestination">Destination type</typeparam>
+public interface IDestinationFactory<in TSource, out TDestination>
+{
+    /// <summary>
+    /// Construct the destination object from the source object
+    /// </summary>
+    /// <param name="source">Source object</param>
+    /// <param name="context">Resolution context</param>
+    /// <returns>New destination instance</returns>
+    TDestination Construct(TSource source, ResolutionContext context);
+}
 /// <summary>
 /// Custom mapping action
 /// </summary>

src/AutoMapper/Configuration/TypeMapConfiguration.cs

@@ -325,6 +325,16 @@ public TMappingExpression ConstructUsing(Func<TSource, ResolutionContext, TDesti
         Expression<Func<TSource, ResolutionContext, TDestination>> expr = (src, ctxt) => ctor(src, ctxt);
         return ConstructUsingCore(expr);
     }
+    public TMappingExpression ConstructUsing<TConstructor>() where TConstructor : IDestinationFactory<TSource, TDestination>
+    {
+        TypeMapActions.Add(tm => tm.ConstructUsingObjectConstructor(typeof(TConstructor)));
+        return this as TMappingExpression;
+    }
+
+    public void ConstructUsing(Type objectConstructorType)
+    {
+        TypeMapActions.Add(tm => tm.ConstructUsingObjectConstructor(objectConstructorType));
+    }
     public void ConvertUsing(Type typeConverterType)
     {
         HasTypeConverter = true;

src/AutoMapper/ServiceCollectionExtensions.cs

@@ -15,7 +15,7 @@ namespace Microsoft.Extensions.DependencyInjection;
 /// Extensions to scan for AutoMapper classes and register the configuration, mapping, and extensions with the service collection:
 /// <list type="bullet">
 /// <item> Finds <see cref="Profile"/> classes and initializes a new <see cref="MapperConfiguration" />,</item> 
-/// <item> Scans for <see cref="ITypeConverter{TSource,TDestination}"/>, <see cref="IValueResolver{TSource,TDestination,TDestMember}"/>, <see cref="IMemberValueResolver{TSource,TDestination,TSourceMember,TDestMember}" />, <see cref="ICondition{TSource,TDestination,TMember}"/>, <see cref="IPreCondition{TSource,TDestination}"/>, <see cref="IValueConverter{TSourceMember,TDestinationMember}"/> and <see cref="IMappingAction{TSource,TDestination}"/> implementations and registers them as <see cref="ServiceLifetime.Transient"/>, </item>
+/// <item> Scans for <see cref="ITypeConverter{TSource,TDestination}"/>, <see cref="IValueResolver{TSource,TDestination,TDestMember}"/>, <see cref="IMemberValueResolver{TSource,TDestination,TSourceMember,TDestMember}" />, <see cref="IDestinationFactory{TSource,TDestination}"/>, <see cref="ICondition{TSource,TDestination,TMember}"/>, <see cref="IPreCondition{TSource,TDestination}"/>, <see cref="IValueConverter{TSourceMember,TDestinationMember}"/> and <see cref="IMappingAction{TSource,TDestination}"/> implementations and registers them as <see cref="ServiceLifetime.Transient"/>, </item>
 /// <item> Registers <see cref="IConfigurationProvider"/> as <see cref="ServiceLifetime.Singleton"/>, and</item>
 /// <item> Registers <see cref="IMapper"/> as a configurable <see cref="ServiceLifetime"/> (default is <see cref="ServiceLifetime.Transient"/>)</item>
 /// </list>
@@ -24,7 +24,7 @@ namespace Microsoft.Extensions.DependencyInjection;
 /// </summary>
 public static class ServiceCollectionExtensions
 {
-    static readonly Type[] AmTypes = [typeof(IValueResolver<,,>), typeof(IMemberValueResolver<,,,>), typeof(ITypeConverter<,>), typeof(IValueConverter<,>), typeof(ICondition<,,>), typeof(IPreCondition<,>), typeof(IMappingAction<,>)];
+    static readonly Type[] AmTypes = [typeof(IValueResolver<,,>), typeof(IMemberValueResolver<,,,>), typeof(ITypeConverter<,>), typeof(IValueConverter<,>), typeof(IDestinationFactory<,>), typeof(ICondition<,,>), typeof(IPreCondition<,>), typeof(IMappingAction<,>)];
     public static IServiceCollection AddAutoMapper(this IServiceCollection services, Action<IMapperConfigurationExpression> configAction)
         => AddAutoMapperClasses(services, (sp, cfg) => configAction?.Invoke(cfg), null);
 

src/AutoMapper/TypeMap.cs

@@ -2,6 +2,8 @@ namespace AutoMapper;
 
 using Features;
 using System.Runtime.CompilerServices;
+using static Expression;
+using static ExpressionBuilder;
 
 /// <summary>
 /// Main configuration object holding all mapping configuration for a source and destination type
@@ -254,6 +256,24 @@ public void IncludeBaseTypes(TypePair baseTypes)
     public void AddAfterMapAction(LambdaExpression afterMap) => Details.AddAfterMapAction(afterMap);
     public void AddValueTransformation(ValueTransformerConfiguration config) => Details.AddValueTransformation(config);
     public void ConstructUsingServiceLocator() => CustomCtorFunction = Lambda(ServiceLocator(DestinationType));
+    public void ConstructUsingObjectConstructor(Type objectConstructorType)
+    {
+        var srcParam = Parameter(SourceType);
+        var ctxParam = Parameter(typeof(ResolutionContext));
+
+        var constructorInstance = ServiceLocator(objectConstructorType);
+        var interfaceType = objectConstructorType.GetGenericInterface(typeof(IDestinationFactory<,>)) ??
+            throw new InvalidOperationException($"Type '{objectConstructorType.Name}' does not implement IDestinationFactory<{SourceType.Name}, {DestinationType.Name}>");
+        var constructMethod = interfaceType.GetMethod("Construct");
+
+        var callExpression = Call(
+            Convert(constructorInstance, interfaceType),
+            constructMethod,
+            srcParam, ctxParam
+        );
+
+        CustomCtorFunction = Lambda(callExpression, srcParam, ctxParam);
+    }
     internal LambdaExpression CreateMapperLambda(IGlobalConfiguration configuration) =>
         Types.ContainsGenericParameters ? null : new TypeMapPlanBuilder(configuration, this).CreateMapperLambda();
     private PropertyMap GetPropertyMap(string name)