Combine ForMember.Ignore with ForAllMembers

[AndrewL97]

In our API, we have an "UpdateRequest" that we use for PATCH and PUT api requests.

The gist of it is that all properties in requests inheriting from UpdateRequest have nullable properties that reflect the (not necessarilly nullable) properties in the db entity.

If a user only wants to update a certain property, like foo, they don't need to populate the rest of the properties, as null properties use the existing db value instead.
If they want to null out a property however, they can add it to the Metadata dictionary with the correct property name.
This is handled in the MapUpdateRequest mapping expression in Mapping Configuration below.

The fiddly bit we have at the moment, is when we have two properties with matching names, but incompatible types, like the Contacts lists in CustomerUpdateRequest and Customer.
We do some extra processing outside of automapper with the Contacts list (we create/delete CustomerContact db records so it matches the IDs passed in the list), and so we don't want automapper to map this property.

We have tried using
ForMember(c => c.Contacts, opt => opt.Ignore()) and ForMember(c => c.Contacts, opt => opt.UseDestinationValue())
but it looks like the ForAllMembers in our MapUpdateRequest method is causing automapper to try to configure the mapping, as it throws AutoMapper.AutoMapperMappingException when we run

var mappedModel = Mapper.Map(customerUpdateRequest, existingCustomer);

I have had a look through docs, unit tests, and stackoverflow and I can't find a solution to this (I might be missing something though)
The closest I could find was the deprecated "ForAllOtherMembers".

Please let me know if you need more info/context/etc.
Thanks in advance :)

Source/destination types

public abstract class UpdateRequest{
    public Dictionary<string, object>? Metadata { get; set; }
}

public class CustomerUpdateRequest : UpdateRequest
{
    public string? foo { get; set; }
    public string? bar { get; set; }
    public List<int>? Contacts { get; set; }
}

public class Customer
{
    public string? foo { get; set; }
    public string? bar { get; set; }
    public Dictionary<string, object>
    public List<Contacts> Contacts { get; set; }
}

Mapping configuration

CreateMap<CustomerUpdateRequest, Customer>()
    ForMember(c => c.Contacts, opt => opt.Ignore())
    .MapUpdateRequest();

public static void MapUpdateRequest<TSource, TDestination>(this IMappingExpression<TSource, TDestination> map) where TSource : UpdateRequest
{
    map.ForAllMembers(options => 
        {
            // If options.DestinationMember.Name is in our Metadata dictionary
            // return the dictionary value
            // Otherwise, if the source value is not null, return the source value
            // Otherwise, use the destination value
        }

Version: 12.0.1

Expected behavior

the Contacts collections would be skipped

Actual behavior

AutoMapper.AutoMapperMappingException is thrown, as we can't map an Int to a Contact

[lbargaoanu]

I think this is better suited for StackOverflow.

[AndrewL97]

Thanks for the quick reply @lbargaoanu :)

I suppose to simplify my nonsense above, I am wanting to clarify if its expected behaviour that running ForMember or ForPath, to ignore a property, will be ignored if a ForAllMembers is used after it

I've done some poking through the code, and the part that I can find that is causing this to occur is in TypeMapPlanBuilder
https://github.com/AutoMapper/AutoMapper/blob/104a192407858fe3a54a8a937ca95a34fd7c6959/src/AutoMapper/Execution/TypeMapPlanBuilder.cs#L181-L182
The ForAllMembers appears to populate the PropertyMaps. My ignored property is in there with all the others (as expected), but it doesn't carry the Ignored forwards, so CanResolveValue is True

Then later in AddPathMaps, its picking up the Ignored flag that the ForMember adds.

I totally understand why ForAllMembers is adding the property as not-ignored, its just confusing and (to me) unexpected that it supersedes the ForMember->ignore

[lbargaoanu]

As the name implies, ForAllMembers applies to all members and overwrites any other config.

[AndrewL97]

Sounds fair!

For anybody else that comes across this with a similar issue, my workaround was to pass member expressions into my MapUpdateRequest method as "IgnoredMembers"

Then inside the ForAllMembers, if the member is in my "IgnoredMembers" list, I return the destinationvalue in a MapFrom