Unflatten by convention with automapper

Question

In my project I'm trying to use automapper to unflatten my command objects to my domain objects by convention as much as possible.
It works when I explicitly map the two members in the mapping profile, but according to the automapper documentation I think this should also work by convention. I created a dotnetfiddle to demonstrate the minimal case.

Related questions end up with people explicitly adding the mapping, but that kind of goes against what Automapper is built for and contradicts the documentation, no? It doesn't work with flattening either, so the reversemap is a red herring I think.

The mapping

public class Mapping: Profile
{
    public Mapping()
    {
        this.CreateMap<CreateSelectionCommand, Selection>();
        // .ForMember(selection => selection.Name, opt => opt.MapFrom(x => x.SelectionName))
        .reverseMap()
    }
}

What I expect to work

[Fact]
public void ShouldMapName()
{
    var cmd = new CreateSelectionCommand {SelectionName = "selectionName"};
    var selection = _mapper.Map<Selection>(cmd);

    Assert.Equal(cmd.SelectionName, selection.Name); <== selection.Name == ""
}

Classes for context

public class Selection
{
    public string Name { get; set; }
}

public class CreateSelectionCommand
{
    public string SelectionName { get; set; }
}

Did I misread the docs or am I missing something?

Guru Stron · Accepted Answer · 2020-12-01T19:36:26.180

Flattening is about mapping nested "complex" objects to properties on "higher" level i.e. in your case if CreateSelectionCommand had property Selection of type which had Name property it would be mapped to SelectionName in destination type (see this fiddle).

You can try to use prefixes by adding:

cfg.RecognizePrefixes("Selection");

to your configuration (see this fiddle) but I doubt that it is suitable option for convention based handling.

Also it seems that you can add custom name convention using ISourceToDestinationNameMapper and AddMemberConfiguration:

class TypeNamePrefixedSourceToDestinationNameMapper : ISourceToDestinationNameMapper
{
    public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo,
        Type destType,
        Type destMemberType, string nameToSearch)
    {
        return getTypeInfoMembers.GetMemberInfos(typeInfo)
            .FirstOrDefault(mi => mi.Name == destType.Name + nameToSearch);
    }
}

var config = new MapperConfiguration(cfg =>
{
    cfg.AddMemberConfiguration().AddName<TypeNamePrefixedSourceToDestinationNameMapper>();

    // ...
}

At least it works in this simple case, see this fiddle.

Good explanation and suggestions. I'll see how far I can get with the convention. Otherwise I'll stick with explicitly defining the mapping — Boris Callens, Dec 02 '20 at 14:16
@BorisCallens was glad to help! Also I was able to do something similar (but looking a bit more hacky) by adding some property mappings in `cfg.ForAllMaps`. — Guru Stron, Dec 02 '20 at 14:24

Unflatten by convention with automapper

1 Answers1