11.0.1 not mapping properties when destination class has constructor with optional parameters

[TAGC]

With AutoMapper v11.0.1, there are some cases where source types will fail to map to destination types if destination types contain a constructor with optional parameters.

This behaviour has been narrowed down to a change produced as part of this commit, specifically the change to the TypeMap.ConstructorParameterMatches method.

Prior to this commit, this method would exclude constructor parameters that were optional (i.e. had default values) but now it includes them. This in turn changes the assignment function that gets created in TypeMapPlanBuilder.CreateAssignmentFunc so that it won't necessarily call any custom map function that is defined for the property.

Further details and a full investigation history can be seen on this StackOverflow post.

Source/destination types

Source types:

public class ParentWriteModel
{
    public ICollection<ChildWriteModel> Children { get; init; }
}

public class ChildWriteModel
{
    public int Foo { get; init; }
}

Destination types:

/// <summary>
/// Parents will indirectly own zero to many <c>Child</c> objects through a <c>ChildGroup</c>.
/// </summary>
public class Parent
{
    public Parent(ChildGroup? childGroup = null)
    {
        ChildGroup = childGroup;
    }

    public ChildGroup ChildGroup { get; private init; }
}

/// <summary>
/// Encapsulates a collection of <c>Child</c> objects and potentially exposes methods to perform aggregate operations on them.
/// </summary>
public class ChildGroup
{
    public ChildGroup(ICollection<Child> thresholds)
    {
        Children = thresholds.ToList();
    }

    public IReadOnlyCollection<Child> Children { get; } = null!;
}

/// <summary>
/// A simple class at the bottom of the class composition hierarchy.
/// </summary>
public class Child
{
    public Child(int foo)
    {
        Foo = foo;
    }

    public int Foo { get; private init; }
}

Mapping configuration

public class ExampleProfile : Profile
{
    public ExampleProfile()
    {
        CreateMap<ParentWriteModel, Parent>().ForMember(
            dest => dest.ChildGroup,
            opt => opt.MapFrom((src, _, _, ctx) =>
            {
                // For v11+, this lambda doesn't get called if 'Parent' contains a constructor with optional parameters.
                return new ChildGroup(ctx.Mapper.Map<List<Child>>(src.Children));
            }));

        CreateMap<ChildWriteModel, Child>();
    }
}

Version: 11.0.1

Expected behavior

Assume the following write model:

var children = new List<ChildWriteModel>
    {
        new()
        {
            Foo = 1
        },
        new()
        {
            Foo = 2
        },
        new()
        {
            Foo = 3
        }
    };

return new ParentWriteModel
{
    Children = children
};

And the following map:

var parent = mapper.Map<Parent>(writeModel);
var count = parent.ChildGroup?.Children.Count;

In v10, all properties would have mapped successfully to the destination types and count would be 3.

Actual behavior

In v11, the ChildGroup property is not mapped.

Steps to reproduce

1. Set up a .NET 6 console app based on this Gist.
2. Install AutoMapper v10.0.0 as a dependency.
3. Execute the program and observe it to run successfully.
4. Switch to AutoMapper v11.0.1.
5. Re-execute AutoMapper and observe it to throw an exception.

[lbargaoanu]

That's by design, you'll have to change your code accordingly.