diff --git a/docs/source/Construction.md b/docs/source/Construction.md
index 945181e64e..f70a5efe2e 100644
--- a/docs/source/Construction.md
+++ b/docs/source/Construction.md
@@ -53,4 +53,77 @@ 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.
\ No newline at end of file
+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>();
+}, typeof(IMyService).Assembly);
+```
+
+For runtime type resolution, use the non-generic overload:
+
+```csharp
+cfg.CreateMap(typeof(Source), typeof(Destination))
+    .ConstructUsing(typeof(CustomConstructor));
+```
+
diff --git a/docs/source/Dependency-injection.md b/docs/source/Dependency-injection.md
index c7ac7d96dd..65a8c7d356 100644
--- a/docs/source/Dependency-injection.md
+++ b/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) ```.
diff --git a/src/AutoMapper.DI.Tests/AppDomainResolutionTests.cs b/src/AutoMapper.DI.Tests/AppDomainResolutionTests.cs
index 3a0dee5ac2..48742dbd66 100644
--- a/src/AutoMapper.DI.Tests/AppDomainResolutionTests.cs
+++ b/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]
diff --git a/src/AutoMapper.DI.Tests/AssemblyResolutionTests.cs b/src/AutoMapper.DI.Tests/AssemblyResolutionTests.cs
index 97f516b0ce..496853e646 100644
--- a/src/AutoMapper.DI.Tests/AssemblyResolutionTests.cs
+++ b/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]
diff --git a/src/AutoMapper.DI.Tests/DependencyTests.cs b/src/AutoMapper.DI.Tests/DependencyTests.cs
index 9756f6378b..ac69c6bb47 100644
--- a/src/AutoMapper.DI.Tests/DependencyTests.cs
+++ b/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);
+        }
+    }
 }
diff --git a/src/AutoMapper.DI.Tests/Profiles.cs b/src/AutoMapper.DI.Tests/Profiles.cs
index d61cbdebab..bd99494daf 100644
--- a/src/AutoMapper.DI.Tests/Profiles.cs
+++ b/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());
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/AutoMapper.DI.Tests/TypeResolutionTests.cs b/src/AutoMapper.DI.Tests/TypeResolutionTests.cs
index 7e3a6c4df0..bae1f186ca 100644
--- a/src/AutoMapper.DI.Tests/TypeResolutionTests.cs
+++ b/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]
diff --git a/src/AutoMapper/Configuration/IMappingExpressionBase.cs b/src/AutoMapper/Configuration/IMappingExpressionBase.cs
index 5be54f1a0d..6763cb6a40 100644
--- a/src/AutoMapper/Configuration/IMappingExpressionBase.cs
+++ b/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).</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).</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>
diff --git a/src/AutoMapper/Configuration/TypeMapConfiguration.cs b/src/AutoMapper/Configuration/TypeMapConfiguration.cs
index 05bb82e2e9..5d69432e63 100644
--- a/src/AutoMapper/Configuration/TypeMapConfiguration.cs
+++ b/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;
diff --git a/src/AutoMapper/ServiceCollectionExtensions.cs b/src/AutoMapper/ServiceCollectionExtensions.cs
index 19278ca6c1..d4d4064a3c 100644
--- a/src/AutoMapper/ServiceCollectionExtensions.cs
+++ b/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);
 
diff --git a/src/AutoMapper/TypeMap.cs b/src/AutoMapper/TypeMap.cs
index 2d4fddd8ef..bf890ffc5b 100644
--- a/src/AutoMapper/TypeMap.cs
+++ b/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,28 @@ 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 expectedInterface = typeof(IDestinationFactory<,>).MakeGenericType(SourceType, DestinationType);
+        if (!expectedInterface.IsAssignableFrom(objectConstructorType))
+        {
+            throw new InvalidOperationException($"Type '{objectConstructorType.Name}' does not implement IDestinationFactory<{SourceType.Name}, {DestinationType.Name}>");
+        }
+        var constructMethod = expectedInterface.GetMethod("Construct") ??
+            throw new InvalidOperationException($"IDestinationFactory<{SourceType.Name}, {DestinationType.Name}> does not define a 'Construct' method.");
+
+        var callExpression = Call(
+            Convert(constructorInstance, expectedInterface),
+            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)
diff --git a/src/UnitTests/Construction/ClassBasedObjectConstructorTests.cs b/src/UnitTests/Construction/ClassBasedObjectConstructorTests.cs
new file mode 100644
index 0000000000..9d87282752
--- /dev/null
+++ b/src/UnitTests/Construction/ClassBasedObjectConstructorTests.cs
@@ -0,0 +1,112 @@
+namespace AutoMapper.UnitTests.Construction;
+
+public class ClassBasedObjectConstructorTests
+{
+    // Test classes
+    public class Source
+    {
+        public int Value { get; set; }
+        public string Name { get; set; }
+    }
+
+    public class Destination
+    {
+        public int Value { get; set; }
+        public string Name { get; set; }
+        public int InitialValue { get; set; }
+    }
+
+    // Destination factory implementations
+    public class CustomConstructor : IDestinationFactory<Source, Destination>
+    {
+        public Destination Construct(Source source, ResolutionContext context)
+        {
+            return new Destination { InitialValue = 100 };
+        }
+    }
+
+    public class SourceAwareConstructor : IDestinationFactory<Source, Destination>
+    {
+        public Destination Construct(Source source, ResolutionContext context)
+        {
+            return new Destination { InitialValue = source.Value * 2 };
+        }
+    }
+
+    [Fact]
+    public void When_using_class_based_object_constructor()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Source, Destination>()
+                .ConstructUsing<CustomConstructor>();
+        });
+
+        var mapper = config.CreateMapper();
+
+        var source = new Source { Value = 10, Name = "Test" };
+        var result = mapper.Map<Destination>(source);
+
+        result.InitialValue.ShouldBe(100);
+        result.Value.ShouldBe(10);
+        result.Name.ShouldBe("Test");
+    }
+
+    [Fact]
+    public void When_using_source_aware_constructor()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Source, Destination>()
+                .ConstructUsing<SourceAwareConstructor>();
+        });
+
+        var mapper = config.CreateMapper();
+
+        var source = new Source { Value = 25, Name = "Test" };
+        var result = mapper.Map<Destination>(source);
+
+        result.InitialValue.ShouldBe(50); // 25 * 2
+        result.Value.ShouldBe(25);
+        result.Name.ShouldBe("Test");
+    }
+
+    [Fact]
+    public void When_using_type_based_constructor_non_generic()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap(typeof(Source), typeof(Destination))
+                .ConstructUsing(typeof(CustomConstructor));
+        });
+
+        var mapper = config.CreateMapper();
+
+        var source = new Source { Value = 10, Name = "Test" };
+        var result = (Destination)mapper.Map(source, typeof(Source), typeof(Destination));
+
+        result.InitialValue.ShouldBe(100);
+        result.Value.ShouldBe(10);
+        result.Name.ShouldBe("Test");
+    }
+
+    [Fact]
+    public void When_mixing_constructor_and_member_mapping()
+    {
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Source, Destination>()
+                .ConstructUsing<SourceAwareConstructor>()
+                .ForMember(d => d.Name, o => o.MapFrom(s => s.Name.ToUpper()));
+        });
+
+        var mapper = config.CreateMapper();
+
+        var source = new Source { Value = 30, Name = "test" };
+        var result = mapper.Map<Destination>(source);
+
+        result.InitialValue.ShouldBe(60); // 30 * 2
+        result.Value.ShouldBe(30);
+        result.Name.ShouldBe("TEST");
+    }
+}