IObjectMapper not resolved/called in child objects

[TsengSR]

I am creating an IObjectMapper (based on the AutoMapper.Collection's EquivalentExpressionCollectionMapper which resolves
entities from EF Core (either query or from it's DbSet<T>().Local store) to preserve the references of the entities when mapping into an entity.

So far it works good, when the collection is property of the mapped object. When the property is part of a child's model referenced by the mapped object, the IObjectMapper instance is not resolved / called.

namespace MyCompany.AutoMapper.Mappers
{
    public class EquivalentExpressionAddSoftDeleteCollectionMapper : EnumerableMapperBase, IConfigurationObjectMapper
    {
        public IConfigurationProvider ConfigurationProvider { get; set; }

        public EquivalentExpressionAddSoftDeleteCollectionMapper()
        {
        }
		
        public override bool IsMatch(TypePair typePair)
        {
            return typePair.SourceType.IsEnumerableType()
                   && typePair.DestinationType.IsCollectionType();
        }

        public override Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, IMemberMap memberMap,
            Expression sourceExpression, Expression destExpression, Expression contextExpression)
        {
            var sourceType = TypeHelper.GetElementType(sourceExpression.Type);
            var destType = TypeHelper.GetElementType(destExpression.Type);
			
            ...
        }
    }
}
``´

The example code is 

        // Arrange
        ManyToManyDto parentDto = new()
        {
            Id = 1,
            Name = "Spouse 1",
            Spouse = new()
            {
                Id = 2,
                Name = "Spouse 2",
                Children = // on this collection, IObjectMapper is **NOT** resolved
                {
                    new ManyToManyChildDto
                    {
                        Id = 1,
                        Name = "Child 1"
                    }
                }
            },
            Children = // on this collection, IObjectMapper is resolved
            {
                new ManyToManyChildDto
                {
                    Id = 1,
                    Name = "Child 1"
                },
                new ManyToManyChildDto
                {
                    Id = 2,
                    Name = "Child 2"
                }
            }
        };

### Source/destination types

```csharp
    public class ManyToManyChild : BasisEntity
    {
        public ManyToManyChild() { }

        public ManyToManyChild(int id)
        {
            Id = id;
        }

        public string Name { get; set; }
        public ICollection<ManyToMany> Parents { get; set; } = new List<ManyToMany>();
    }

    public class ManyToMany : BasisEntity
    {
        public ManyToMany() { }

        public ManyToMany(int id)
        {
            Id = id;
        }

        public ICollection<ManyToManyChild> Children { get; set; } = new List<ManyToManyChild>();
        public string Name { get; set; }
        public ManyToMany Spouse { get; set; }
    }

    public class ManyToManyChildDto : BasisDto
    {
        public string Name { get; set; }
        public List<ManyToManyDto> Parents { get; set; } = new();
    }

    public class ManyToManyDto : BasisDto
    {
        public ManyToManyDto Spouse { get; set; }
        public List<ManyToManyChildDto> Children { get; set; } = new();
        public string Name { get; set; }
    }

Mapping configuration

            CreateMap<BasisEntity, BasisDto>()
                .Include<ManyToManyChild, ManyToManyChildDto>()
                .Include<ManyToMany, ManyToManyDto>();

            CreateMap<ManyToManyChild, ManyToManyChildDto>().ReverseMap();
            CreateMap<ManyToMany, ManyToManyDto>().ReverseMap();

// Initialize
            var config = new MapperConfiguration(config =>
            {
                config.AddMyCollectionMappers();
                config.UseEntityFrameworkCoreModel<MapperDbContext>();
                config.AddProfile<MetaDataMappingProfile>();
            });

            var autoMapper = config.CreateMapper();

Version: 10,1.1

EF Core 5.0
AutoMapper.Collection 7.0.1
AutoMapper.Collection.EntityFrameworkCore 7.0.1

Expected behavior

That IObjectMapper is called on child properties (parentDto.Spouse.Children) as it is on parentDto.Children too.

Actual behavior

IObjectMapper is only resolved on parentDto.Children

Steps to reproduce

// would usually come from EF Core, but for unit test thats enough
ManyToMany entity = new ManyToMany() { Id = 1 }; 

ManyToMany result = Mapper.Map(parentDto, entity, options => 
{
   options.Items["resolver"] = ...; /instance of IEntityResolver which is used by the IObjectMapper to resolve entities from EF Core
});

[TsengSR]

I've spent 3 days (a 8 hours) trying to find the issue to no avail. Must be something the library does internally to resolve child model's properties differently than the main object and it's child properties. After calling mapper.Map(source, destination) its not up in my hands anymore.

And that it's called on parentDto.Children but not parentDto.Spouse.Children suggests AutoMapper doing something differently when resolving / mapping the Spouse property which causes the IObjectMapper not beign resolved properly.

Even putting the custom IObjectMapper first in the list of mappers doesn't resolve the issue

[jbogard]

I think the next step is to reference the code directly, or use the debug symbols to poke in. Could be that it's using the internal object caching?

[TsengSR]

I can't for my life find out where the actual mapping is performed. No matter how often, slow or accurate I debug or step into the methods, I never end up in any of the IObjectMapper except in my own

The closest sections I can step into are

        private TDestination MapCore<TSource, TDestination>(
            TSource source, TDestination destination, ResolutionContext context, Type sourceType = null, Type destinationType = null, IMemberMap memberMap = null)
        {
            return ConfigurationProvider.GetExecutionPlan<TSource, TDestination>(MapRequest())(source, destination, context);
            MapRequest MapRequest()
            {
                var runtimeTypes = new TypePair(source?.GetType() ?? sourceType ?? typeof(TSource), destination?.GetType() ?? destinationType ?? typeof(TDestination));
                var requestedTypes = new TypePair(typeof(TSource), typeof(TDestination));
                return new MapRequest(requestedTypes, runtimeTypes, memberMap);
            }
        }

and the GetExecutionPlan rexpectively.

before it calls the next one. I have absolutely no means to see what happens after the execution plan is picked up (or even what's picked up). I already spent like 6-7 days now trying to debug it and step into it and I am not the tiniest bit closer to the solutioon or reason for this to happen.
I can't do that forever in a library I am not at least familiar with it's internal working since I have deadlines to meet and this issue is currently blocking me.

I know that my implementation of the IObjectMapper IS working, since its called and works properly and also deduplicates the references if the duplicate entity in parentDto.Children. It would also deduplicate it in parent.Spouse.Children, but my IObjectMapper is never called on that path.

With this model, the deduplication works flawlessly

        ManyToManyDto parentDto = new()
        {
            Id = 1,
            Name = "Spouse 1",
            Spouse = new()
            {
                Id = 2,
                Name = "Spouse 2"
            },
            Children = // on this collection, IObjectMapper is resolved
            {
                new ManyToManyChildDto
                {
                    Id = 1,
                    Name = "Child 1"
                },
                {
                    new ManyToManyChildDto
                    {
                        Id = 1,
                        Name = "Child 1"
                    }
                },
                new ManyToManyChildDto
                {
                    Id = 2,
                    Name = "Child 2"
                }
            }
        };

Which ends up with a collection of 2 items.

I have no idea where or how AutoMapper caches stuff inside or why it would suddenly use a different IObjectMapper for collectinos of a child property of the model.

[TsengSR]

I think the next step is to reference the code directly, or use the debug symbols to poke in. Could be that it's using the internal object caching?

After further spending many more days, I got at least a little bit closer. Still can't explain the behvaior, any hints?

When I call it with

// would usually come from EF Core, but for unit test thats enough
ManyToMany entity = new ManyToMany() { Id = 1 }; 

ManyToMany result = Mapper.Map(parentDto, entity, options => 
{
   options.Items["resolver"] = ...; /instance of IEntityResolver which is used by the IObjectMapper to resolve entities from EF Core
});

It doesn't work. But when initializing the Spouse with an empty object, it does.

// would usually come from EF Core, but for unit test thats enough
ManyToMany entity = new ManyToMany() { Id = 1, Spouse = new() }; 

ManyToMany result = Mapper.Map(parentDto, entity, options => 
{
   options.Items["resolver"] = ...; /instance of IEntityResolver which is used by the IObjectMapper to resolve entities from EF Core
});

Why? When Spouse is null, a new instance of ManyToMany() will be created and my IObjectMapper implementation won't be called. When it's not null, it does.

This works in the unit test, but of course in real world I wouldn't know which properties are null or not when starting the mapping, so what could be interfering here?

[lbargaoanu]

Mappers don't get to handle null. You need maps for that. Null is handled before the mappers, so mappers can just assume the source is not null. The result when the source is null doesn't depend on what mappers do, it depends on AllowNullDestinationValues and AllowNullCollections.

[TsengSR]

That's pretty confusing to understand. In both cases the Spouse type is instantiated and mapped, but when it's Spouse = null, the IObjectMapper (i.e. my and I assume the AutoMapper.Collection one too). I always assumed AutoMapper will instantiate it and then apply the mappers to it.

AllowNullDestinationValues = false is not heling in this case either, as the unit test just freezes and gets abrupted (I assume due to StackOverflow, since ManyToMany references itself in the Spouse property.

But I actually don't need the mapper to handle null, since the object is created even when AllowNullDestinationValues = false. I only need the mappers called after Spouse (instance of ManyToMany) has been created and is about to be mapped

[TsengSR]

So again, at which point do I need to hook in, extend or register something, to make sure that this IObjectMapper (or any other AutoMapper related interface) will be called on mapping of every collection/array (and ideally any complex object)?