A better way to use AutoMapper to flatten nested objects?
Solution 1
I much prefer avoiding the older Static methods and do it like this.
Place our mapping definitions into a Profile. We map the Root first, and then apply the mappings of the Nested afterwards. Note the use of the Context.
public class MappingProfile : Profile
{
public MappingProfile()
{
CreateMap<Root, Flattened>()
.AfterMap((src, dest, context) => context.Mapper.Map(src.TheNestedClass, dest));
CreateMap<Nested, Flattened>();
}
}
The advantage of defining both the mapping from Root to Flattened and Nested to Flatterned is that you retain full control over the mapping of the properties, such as if the destination property name is different or you want to apply a transformation etc.
An XUnit test:
[Fact]
public void Mapping_root_to_flattened_should_include_nested_properties()
{
// ARRANGE
var myRoot = new Root
{
AParentProperty = "my AParentProperty",
TheNestedClass = new Nested
{
ANestedProperty = "my ANestedProperty"
}
};
// Manually create the mapper using the Profile
var mapper = new MapperConfiguration(cfg => cfg.AddProfile(new MappingProfile())).CreateMapper();
// ACT
var myFlattened = mapper.Map<Root, Flattened>(myRoot);
// ASSERT
Assert.Equal(myRoot.AParentProperty, myFlattened.AParentProperty);
Assert.Equal(myRoot.TheNestedClass.ANestedProperty, myFlattened.ANestedProperty);
}
By adding AutoMapper's serviceCollection.AddAutoMapper() from the AutoMapper.Extensions.Microsoft.DependencyInjection nuget package to your start up, the Profile will be picked up automatically, and you can simply inject IMapper into wherever you are applying the mapping.
Solution 2
In the latest version of AutoMapper, there's a naming convention you can use to avoid multiple .ForMember statements.
In your example, if you update your Flattened class to be:
public class Flattened
{
public string AParentProperty { get; set; }
public string TheNestedClassANestedProperty { get; set; }
}
You can avoid the use of the ForMember statement:
Mapper.CreateMap<Root, Flattened>();
Automapper will (by convention) map Root.TheNestedClass.ANestedProperty
to Flattened.TheNestedClassANestedProperty
in this case. It looks less ugly when you're using real class names, honest!
Solution 3
2 more possible solutions:
Mapper.CreateMap<Nested, Flattened>()
.ForMember(s=>s.AParentProperty, o=>o.Ignore());
Mapper.CreateMap<Root, Flattened>()
.ForMember(d => d.ANestedProperty, o => o.MapFrom(s => s.TheNestedClass));
An alternative approach would be the below, but it would not pass the Mapper.AssertConfigurationIsValid()
.
Mapper.CreateMap<Nested, Flattened>()
//.ForMember map your properties here
Mapper.CreateMap<Root, Flattened>()
//.ForMember... map you properties here
.AfterMap((s, d) => Mapper.Map(s.TheNestedClass, d));
Solution 4
Not sure if this adds value to the previous solutions, but you could do it as a two-step mapping. Be careful to map in correct order if there are naming conflicts between the parent and child (last wins).
Mapper.CreateMap<Root, Flattened>();
Mapper.CreateMap<Nested, Flattened>();
var flattened = new Flattened();
Mapper.Map(root, flattened);
Mapper.Map(root.TheNestedClass, flattened);
Solution 5
To improve upon another answer, specify MemberList.Source
for both mappings and set the nested property to be ignored. Validation then passes OK.
Mapper.Initialize(cfg =>
{
cfg.CreateMap<SrcNested, DestFlat>(MemberList.Source);
cfg.CreateMap<SrcRoot, DestFlat>(MemberList.Source)
.ForSourceMember(s => s.Nested, x => x.Ignore())
.AfterMap((s, d) => Mapper.Map(s.Nested, d));
});
Mapper.AssertConfigurationIsValid();
var dest = Mapper.Map<SrcRoot, DestFlat>(src);
Related videos on Youtube
John
Updated on July 09, 2022Comments
-
John almost 2 years
I have been flattening domain objects into DTOs as shown in the example below:
public class Root { public string AParentProperty { get; set; } public Nested TheNestedClass { get; set; } } public class Nested { public string ANestedProperty { get; set; } } public class Flattened { public string AParentProperty { get; set; } public string ANestedProperty { get; set; } } // I put the equivalent of the following in a profile, configured at application start // as suggested by others: Mapper.CreateMap<Root, Flattened>() .ForMember ( dest => dest.ANestedProperty , opt => opt.MapFrom(src => src.TheNestedClass.ANestedProperty) ); // This is in my controller: Flattened myFlattened = Mapper.Map<Root, Flattened>(myRoot);
I have looked at a number of examples, and so far this seems to be the way to flatten a nested hierarchy. If the child object has a number of properties, however, this approach doesn't save much coding.
I found this example:
but it requires instances of the mapped objects, required by the Map() function, which won't work with a profile as I understand it.
I am new to AutoMapper, so I would like to know if there is a better way to do this.
-
Cristian Diaconescu almost 9 yearsNice approach; too bad calling
Mapper.AssertConfigurationIsValid();
on this configuration fails with two errors (there are two maps created, none of which completely covers the destination type's properties) -
Peter McEvoy over 8 yearsnot sure how this solves the problem if there are a lot of fields in the nested class? The OP wants to avoid adding mulitple "For destination Member" statements if there are multiple properties in the Flattened object that should map from the Nested object.
-
Alex M over 8 yearsIt is just an alternative to naming conventions approach. Not all the time one has a possibility to change/refactor property names all the way down to conform to naming conventions of AutoMapper.
-
jocull over 7 yearsThe 2nd pass with an
.AfterMap
step is what I needed -- thanks! -
Choco over 6 yearsnaming my view model properties based on the use of Automapper is not something I would like to do. I appreciated the answer but the side effects of the solution would have me use the technique in the original question.
-
Rudey over 6 yearsI can't get this to work using the newest version of AutoMapper. MappingExpression.TypeMap isn't available anymore.