AutoMapAttribute, IncludeAllDerived and ReverseMap not working with polymorphic derived reversed map

[chrisdreams13]

Using AutoMapAttribute, IncludeAllDerived and ReverseMap should returns derived class trying a reverse Map<T>() method. As sugestion IncludeAllDerivedForReverseMap property could be added if interferes with other purposes.

Source/destination types

public class ArticleDB
{
    public int Id { get; set; }
    public virtual ProductDB Product { get; set; }
}

public class ProductDB
{
    public int Id { get; set; }
}

public class ProductChildDB : ProductDB
{
    public float Cost { get; set; }
}

[AutoMap(typeof(ArticleDB), ReverseMap = true)]
public class Article
{
    public int Id { get; set; }
    public virtual Product Product { get; set; }
}

[AutoMap(typeof(ProductDB), IncludeAllDerived = true, ReverseMap = true)]
public class Product
{
    public int Id { get; set; }
}

[AutoMap(typeof(ProductChildDB), ReverseMap = true)]
public class ProductChild : Product
{
    public float Cost { get; set; }
}

Mapping configuration

// Auto configuration using dependency injection and AutoMapAttribute

var services = new ServiceCollection();
services.AddAutoMapper(typeof(MapperProfile));
var provider = services.BuildServiceProvider();

var mapper = provider.GetService<IMapper>()!

Version: x.y.z

<PropertyGroup>
    <TargetFramework>net6.0</TargetFramework>
</PropertyGroup>
<PackageReference Include="AutoMapper" Version="11.0.1" />
<PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="11.0.0" />
<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="6.0.0" />

Expected behavior

When ReverseMap and IncludeAllDerived are set in AutoMapAttribute, method Map<T>() should return correct derived object's class when destination is a derived class.

var articleDB = new ArticleDB { Id = 1, Product = new ProductChildDB { Id = 2, Cost = 1.1f } };
var result = mapper.Map<Article>(articleDB);

var resultReverse = mapper.Map<ArticleDB>(result);
Debug.Assert(resultReverse.Product is ProductChildDB); // <- Product should be a ProductChildDB

Actual behavior

Polimorphic object is a parent class (ProductDB) instead of it's derived class (ProductChildDB)

var articleDB = new ArticleDB { Id = 1, Product = new ProductChildDB { Id = 2, Cost = 1.1f } };
var result = mapper.Map<Article>(articleDB);

var resultReverse = mapper.Map<ArticleDB>(result);
Debug.Assert(resultReverse.Product is ProductChildDB); // <- Product is a ProductDB

Steps to reproduce

1. Create a class that contains polymorphic derived class using [AutoMap(typeof(ProductDB), IncludeAllDerived = true, ReverseMap = true)].
2. Create an object of the destination class (ReverseMap object).
3. Try to Map that object.
4. Assert derived reversed object is an object of derived class.

see https://gist.github.com/chrisdreams13/b1746c91f7cc2da4b3f358728fde5792

NOTE: This only occurs with AutoMapAttribute configuration, if CreateMap is using in MapperProfile works ok.

[lbargaoanu]

Everything works as expected here. IncludeAllDerived is not reversed and it shouldn't be, because it's expensive. You can simply avoid ReverseMap and declare explicitly the two maps.

[lbargaoanu]

The way I see it, attributes should work for simple cases and for the rest you should fallback to the fluent API.
But @jbogard could be open to a PR.

[jbogard]

Yeah I agree - the attributes are for dirt dirt simple mappings, and especially for polymorphic ones, it's easier to understand when all of the related mapping configuration is declared together. I put those in a single Profile then have all the derived ones right there too.

[chrisdreams13]

Ok I understand your point, but I prefer to have the configuration in same file as mapper class. I had created a 3rd project with my new AutoMapReverseAttribute and a service extension that covers all my purposes. Thanks for your time.

AutoMapperExtensions

public static class AutoMapperExtensions
{
    public static IServiceCollection AddAutoMapper(this IServiceCollection services) =>
        services.AddTransient(_ => new MapperConfiguration(CreateMaps).CreateMapper());

    public static IServiceCollection AddAutoMapper<T>(this IServiceCollection services) where T : Profile, new() =>
        services.AddTransient(_ => new MapperConfiguration(cfg =>
        {
            CreateMaps(cfg);
            cfg.AddProfile<T>();
        }).CreateMapper());

    private static void CreateMaps(IMapperConfigurationExpression cfg)
    {
        foreach (var type in Assembly.GetExecutingAssembly().GetTypes())
        {
            foreach (var autoMapAttribute in type.GetCustomAttributes<AutoMapAttribute>(false))
            {
                var map = cfg.CreateMap(type, autoMapAttribute.SourceType);
                autoMapAttribute.ApplyConfiguration(map);
            }

            foreach (var autoMapAttribute in type.GetCustomAttributes<AutoMapReverseAttribute>(false))
            {
                var map = cfg.CreateMap(autoMapAttribute.DestinationType, type);
                autoMapAttribute.ApplyConfiguration(map);
            }
        }
    }
}

if you would like to close the conversation it's ok

[jbogard]

Why can't you put the Profile in the same file? Or even as an inner class if you like

[chrisdreams13]

I believe in the phrase "easier to write, easier to understand and easier to change later". Set it in a Profile file result in a maintenance problem, as you need to check 2 files to modify one class. Set it in an inner class creates unnecessary code in the dll and RAM and for the eye a bigger class is difficult to read.
Finally, I guess that if the system work from left to right, why couldn't work right to left in the same way.