Mapping configuration is not considered and constructor is used instead

[JoFrMueller]

Source/destination types

The example is a console app that can be used 1:1.

Mapping configuration

Example code contains mapping configuration.

Version:

11.0.0

Expected behavior

Mapping configuration should apply instead of "magic" constructor call.

Actual behavior

The mapping configuration isn't considered at all.

Steps to reproduce

namespace ConsoleApp2
{
    class Program
    {
        static void Main(string[] args)
        {
            var config = new MapperConfiguration(cfg => {
                cfg.CreateMap<A, B>().ForMember(dest => dest.Credential, opt => opt.MapFrom(src => $"{src.Credential}|{src.Credential}"));
            });
            IMapper mapper = config.CreateMapper();
            var result = mapper.Map<B>(new A
            {
                Credential = "test"
            });

            if (result.Credential == "test")
            {
                throw new Exception("This was not expected... We expected test|test...");
            }
        }
    }
    
    class A
    {
        public string Credential { get; set; }
    }

    class B
    {
        public string Credential { get; private set; }

        public B()
        {
        }

        // If this constructor is removed, it behaves as expected.
        public B(string credential)
        {
            Credential = credential;
        }

        public void SetCredential(string credential)
        {
            Credential = credential;
        }
    }
}

Any further information or guidance on this?
In this example, the error is trivial to spot, but we had it in a more complex mapping configuration and we were desperately wondering what the rules exactly are, that decide if constructor parameter mapping or mapping configuration "wins"...

[lbargaoanu]

Things are not mapped twice, that's the rule :) Maybe just disable constructor mapping? There are many similar questions, here and on SO.

[lbargaoanu]

All you need is if (validationContext.TypeMap?.ConstructorMapping is true) {...}.
You can also check how the validator uses AggreggateException to throw one exception for multiple errors.

[ChristophHornung]

@lbargaoanu 👍 Thanks for the hints, I will look into the validation exceptions.

[lbargaoanu]

To simplify usage, I've moved the ConstructorMapping check inside ConstructorParameterMatches, so it can be removed at the call site.

[ChristophHornung]

@lbargaoanu Awesome, thanks! Looking forward to the next nuget release to update my code.

[ChristophHornung]

For anyone interested: This is the code updated to 12.0 (the custom IsResolveConfigured method is no longer required)

private static void ValidateDuplicateMappings(ValidationContext validationContext)
	{
		foreach (PropertyMap map in validationContext.TypeMap?.PropertyMaps.Where(m =>
			                            m.IsResolveConfigured &&
			                            validationContext.TypeMap.ConstructorParameterMatches(m.DestinationName)) ??
		                            new List<PropertyMap>())
		{
			throw new AutoMapperConfigurationException(
				$"Duplicate mapping in both constructor and member map for {map.TypeMap.DestinationType.FullName} : {map.DestinationName}");
		}
	}