Let's say I have the following classes
class Foo
{
public Bar First { get; }
public Bar Second { get; }
public Foo(Bar first, Bar second)
{
First = first;
Second = second;
}
}
class Bar
{
public string Name { get; set; }
}
class FooDto
{
public string FirstName { get; set; }
public string SecondName { get; set; }
}
and I want to map FooDto to Foo. I've read about Reverse Mapping and Unflattening so I setup my confoguration like so:
IMapper mapper = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Foo, FooDto>()
.ReverseMap();
}).CreateMapper();
Unfortunately this fails with
System.ArgumentException : Test.AutoMapper.Foo needs to have a constructor with 0 args or only optional args.
How can I configure AutoMapper to use the Foo constructor without manually mapping all constructor parameters? (In my actual code, the types have more properties)
You have to declare the conversion explicitly, cause the names of the constructor arguments and property names differ. For further informations take a look at the documentation.
Here is a running example:
public static void Main()
{
var configuration = new MapperConfiguration(config =>
{
config.CreateMap<FooDto, Foo>()
.ForCtorParam("first", opt => opt.MapFrom(src => src.FirstName))
.ForCtorParam("second", opt => opt.MapFrom(src => src.SecondName));
config.CreateMap<string, Bar>().ConvertUsing(value => new Bar() { Name = value });
});
var mapper = configuration.CreateMapper();
var dto = new FooDto() { FirstName = "Hello", SecondName = "World" };
var foo = mapper.Map<Foo>(dto);
Console.WriteLine(foo.First.Name);
Console.WriteLine(foo.Second.Name);
}
Related
I want to map source inner classes to string and in other case string array but in both cases they are mapped to null. I want MapNoteFromInnerSourceEntity1 to hold a value of InnerSourceEntity1 Id property and MapValueFromInnerSourceEntity2 to hold values of InnerSourceEntity2 value properties. So far automapper is quite difficult for me to understand.
Code:
internal class Program
{
public class InnerSourceEntity1
{
public string Id { get; set; }
public string Note { get; set; }
}
public class InnerSourceEntity2
{
public string Id { get; set; }
public string Value { get; set; }
}
public class SourceEntity
{
public InnerSourceEntity1 A { get; set; }
public IList<InnerSourceEntity2> B { get; set; }
}
public class DestinationEntity
{
public string MapNoteFromInnerSourceEntity1 { get; set; }
public string[] MapValueFromInnerSourceEntity2 { get; set; }
}
static void Main()
{
var source = new SourceEntity
{
A = new InnerSourceEntity1 { Note = "Note", Id = "Id"},
B = new List<InnerSourceEntity2> { new InnerSourceEntity2 { Id = "Id", Value = "Value" }, new InnerSourceEntity2 { Id = "Id", Value = "Value" } }
};
var config = new MapperConfiguration(cfg => {
cfg.CreateMap<SourceEntity, DestinationEntity>();
cfg.CreateMap<InnerSourceEntity1, string>().ConvertUsing(s => s.Note);
cfg.CreateMap<IList<InnerSourceEntity2>, string[]>();
});
var mapper = new Mapper(config);
DestinationEntity destination = mapper.Map<SourceEntity, DestinationEntity>(source);
Console.ReadLine();
}
}
Since the names of properties between source type SourceEntity and destination type DestinationEntity don't match, you'll have to explicitly indicate them, otherwise AutoMapper will not know how to fill the properties:
cfg.CreateMap<SourceEntity, DestinationEntity>()
.ForMember(
dst => dst.MapNoteFromInnerSourceEntity1,
opts => opts.MapFrom(src => src.A))
.ForMember(
dst => dst.MapValueFromInnerSourceEntity2,
opts => opts.MapFrom(src => src.B));
Also, don't map between concrete collection types:
cfg.CreateMap<IList<InnerSourceEntity2>, string[]>(); // <== Don't do that.
Instead, see what the docs say about mapping collections:
(...) it’s not necessary to explicitly configure list types, only their member types. ~ AutoMapper Docs
So, you only need to specify map like this:
cfg.CreateMap<InnerSourceEntity2, string>();
And since we are mapping to string we also need to instruct the AutoMapper from where it can get the string value. So, we'll use ConvertUsing() again:
cfg.CreateMap<InnerSourceEntity2, string>().ConvertUsing(s => s.Value);
Final configuration:
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<SourceEntity, DestinationEntity>()
.ForMember(
dst => dst.MapNoteFromInnerSourceEntity1,
opts => opts.MapFrom(src => src.A))
.ForMember(
dst => dst.MapValueFromInnerSourceEntity2,
opts => opts.MapFrom(src => src.B));
cfg.CreateMap<InnerSourceEntity1, string>().ConvertUsing(s => s.Note);
cfg.CreateMap<InnerSourceEntity2, string>().ConvertUsing(s => s.Value);
});
The models I'm working with include an entry object which I'd like to map as if its child object were the entire object.
Here is a simplified version of the problem. I'd like an instance of OurWrappedSource to map directly to OurTarget.
class OurTarget
{
public Guid Id { get; set; }
public string Notes { get; set; }
public int Quantity { get; set; }
}
class OurSource
{
public Guid Id { get; set; }
public string Notes { get; set; }
public int Quantity { get; set; }
}
class OurWrappedSource
{
public OurSource Source { get; set; }
}
private static void TestUnwrapUsingConfig(MapperConfiguration config)
{
config.AssertConfigurationIsValid();
IMapper mapper = new Mapper(config);
var wrappedSource = new OurWrappedSource
{
Source = new OurSource
{
Id = new Guid("123e4567-e89b-12d3-a456-426655440000"),
Notes = "Why?",
Quantity = 27
}
};
var target = mapper.Map<OurTarget>(wrappedSource);
Assert.Equal(wrappedSource.Source.Id, target.Id);
Assert.Equal(wrappedSource.Source.Notes, target.Notes);
Assert.Equal(wrappedSource.Source.Quantity, target.Quantity);
}
The following configuration works, but is unwieldy for more than a couple of members:
// Works, but isn't *auto* enough
TestUnwrapUsingConfig(new MapperConfiguration(cfg =>
{
cfg.CreateMap<OurWrappedSource, OurTarget>()
.ForMember(src => src.Id, opts => opts.MapFrom(wrappedSource => wrappedSource.Source.Id))
.ForMember(src => src.Notes, opts => opts.MapFrom(wrappedSource => wrappedSource.Source.Notes))
.ForMember(src => src.Quantity, opts => opts.MapFrom(wrappedSource => wrappedSource.Source.Quantity));
}));
What I'd like to be able to do is define two intermediate mappings an then compose them:
Map OurWrappedSource directly to OurSource
Map OurSource directly to OurTarget
Map OurWrappedSource to OurTarget by composing mapping 1 with mapping 2
After some hammering, I have this configuration:
// Works, but #3 probably isn't ProjectTo-friendly
TestUnwrapUsingConfig(new MapperConfiguration(cfg =>
{
// 1
cfg.CreateMap<OurWrappedSource, OurSource>()
.ConvertUsing(wrappedSource => wrappedSource.Source);
// 2
cfg.CreateMap<OurSource, OurTarget>();
// 3
cfg.CreateMap<OurWrappedSource, OurTarget>()
.ConstructUsing((wrappedSource, ctx) =>
ctx.Mapper.Map<OurTarget>(ctx.Mapper.Map<OurSource>(wrappedSource))
)
.ForAllOtherMembers(opts => opts.Ignore());
}));
This works exactly as specified, but mapping 3 seems perhaps a little more explicit and/or kludgey than it should. It involves code in a Func (rather than an expression), which makes me think it probably won't optimize well when used with ProjectTo(). Is there a way to rewrite mapping 3 to address these issues?
I am using AutoMapper 6.2.2, I have two source models that share an Id property:
using System.Diagnostics;
using AutoMapper;
public class Outer
{
public int Id { get; set; }
public string Foo { get; set; }
public Inner Bar { get; set; }
}
public class Inner
{
public int Id { get; set; }
public string Baz { get; set; }
public string Qux { get; set; }
public string Bof { get; set; }
}
public class FlatDto
{
public int Id { get; set; }
public string Foo { get; set; }
public string Baz { get; set; }
public string Qux { get; set; }
public string Bof { get; set; }
}
public class AutoMapperProfile : Profile
{
public AutoMapperProfile()
{
this.CreateMap<Outer, FlatDto>()
.ForMember(dst => dst.Id, opt => opt.MapFrom(s => s.Id))
.ForMember(dst => dst.Foo, opt => opt.MapFrom(s => s.Foo))
.ForMember(dst => dst.Baz, opt => opt.MapFrom(s => s.Bar.Baz))
.ForMember(dst => dst.Qux, opt => opt.MapFrom(s => s.Bar.Qux))
.ForMember(dst => dst.Bof, opt => opt.MapFrom(s => s.Bar.Bof));
}
}
class Program
{
static void Main(string[] args)
{
Outer model = new Outer
{
Id = 1,
Foo = "FooString",
Bar = new Inner
{
Id = 2,
Baz = "BazString",
Qux = "QuxString",
Bof = "BofString"
}
};
var config = new MapperConfiguration(cfg => cfg.AddProfiles(typeof(Program).Assembly));
config.AssertConfigurationIsValid();
IMapper mapper = new Mapper(config);
FlatDto dto = mapper.Map<Outer, FlatDto>(model);
Trace.Assert(model.Id == dto.Id);
Trace.Assert(model.Foo == dto.Foo);
Trace.Assert(model.Bar.Baz == dto.Baz);
Trace.Assert(model.Bar.Qux == dto.Qux);
Trace.Assert(model.Bar.Bof == dto.Bof);
}
}
I want FlatDto.Id to come from Outer and the other parameters all by name. AutoMapper's convention in this case is pretty clear however I cannot modify these properties. It's currently mapped explicitly with ForMember for every dest property. The solution for a similar question actually is even longer.
Does a more elegant solution exist for this case where both models contain several fields and only one overlaps and requires explicit handling?
The simplest solution (without changing code even you modified Outer/Inner in the future) is:
Mapper.Initialize(c =>
{
c.CreateMap<Inner, FlatDto>();
c.CreateMap<Outer, FlatDto>().BeforeMap((s, t) => Mapper.Map(s.Bar, t));
});
Be aware that:
You need to change if you are using instance mappers instead of static .Map method of "global" mapper.
Properties with same name in both Inner and Outer will be mapped twice, and the Outer has a higher priority, be careful with possible side effects.
EDIT Since you are using instance mappers and profiles, the instance IMapper can't be accessed inside a profile, we need to register the mappings dynamic. The following code, just like the code snippet in the question, essentially uses .ForMember, with the arguments built in dynamic expressions.
class TestProfile : Profile
{
public TestProfile()
{
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
Func<PropertyInfo, bool> filter = p => p.CanRead && p.CanWrite;
var outerProperties = typeof(Outer).GetProperties(flags).Where(filter).ToDictionary(p => p.Name);
var innerProperties = typeof(Inner).GetProperties(flags).Where(filter);
var mappingProperties = innerProperties.Where(p => !outerProperties.ContainsKey(p.Name));
//code above gets the properties of Inner that needs to be mapped
var outerParameter = Expression.Parameter(typeof(Outer));
var accessBar = Expression.Property(outerParameter, nameof(Outer.Bar));
var map = CreateMap<Outer, FlatDto>();
var mapExp = Expression.Constant(map);
foreach (var property in mappingProperties)
{
var accessProperty = Expression.MakeMemberAccess(accessBar, property);
var funcType = typeof(Func<,>).MakeGenericType(typeof(Outer), property.PropertyType);
var funcExp = Expression.Lambda(funcType, accessProperty, outerParameter);
//above code builds s => s.Bar.Qux
var configType = typeof(IMemberConfigurationExpression<,,>).MakeGenericType(typeof(Outer), typeof(FlatDto), typeof(object));
var configParameter = Expression.Parameter(configType);
var mapFromMethod = configType
.GetMethods()
.Single(m => m.Name == "MapFrom" && m.IsGenericMethod)
.MakeGenericMethod(property.PropertyType);
var invokeMapFrom = Expression.Call(configParameter, mapFromMethod, funcExp);
var configExp = Expression.Lambda(typeof(Action<>).MakeGenericType(configType), invokeMapFrom, configParameter);
//above code builds opt => opt.MapFrom(s => s.Bar.Qux)
var forMemberMethod = map.GetType()
.GetMethods()
.Single(m => m.Name == "ForMember" && !m.IsGenericMethod);
var invokeForMember = Expression.Call(mapExp, forMemberMethod, Expression.Constant(property.Name), configExp);
//above code builds map.ForMember("Qux", opt => opt.MapFrom(s => s.Bar.Qux))
var configAction = Expression.Lambda<Action>(invokeForMember);
configAction.Compile().Invoke();
}
}
}
Looks very huge code but in fact you can(and should) put the get property/method snippet somewhere else, the foreach loop itself uses them to build an expression to invoke. It's quite clean and effective.
I'm seeing some very strange behaviour in Automapper when mapping from a object with a single Nullable<bool> property. I currently have it set up like this:
public class MyViewModel
{
public bool? IsAThing { get; set; }
}
public class MyEntity
{
public bool? IsAThing { get; set; }
public bool? HasAnotherThing { get; set; }
public string AnotherThing { get; set; }
// Lots of other fields
}
with the following mapping profile (with a similar reverse mapping):
CreateMap<MyViewModel, MyEntity>()
.ForMember(x => x.IsAThing, opt => opt.MapFrom(y => y.IsAThing))
.ForAllOtherMembers(opt => opt.Ignore());
However if I try to do the following:
var config = new AutoMapperConfig().Configure();
var mapper = config.CreateMapper();
var source = new MyViewModel { IsAThing = true };
var dest = new MyEntity();
mapper.Map(source, dest);
dest.IsAThing is null. The mapping profile is the only place where MyViewModel is declared as a mapping source. Strangely, if I declare the class
public class AnotherThingViewModel
{
public bool? HasAnotherThing { get; set; }
public string AnotherThing { get; set; }
}
And do the following test:
var source = new AnotherThingViewModel { HasAnotherThing = true };
var dest = new MyEntity();
mapper.Map(source, dest);
dest.HasAnotherThing is true as expected!
Obviously I have no idea what's going on here so has anyone seen anything like this before, or knows of any bugs in Automapper that might cause this?
I figured it out, I had CreateMap<MyViewModel, MyEntity>().ForAllMembers(opt => opt.Ignore()) elsewhere in my mapping configuration!
I am in need to map the below scenario.
public class Customer
{
public string CustomerJson { get; set; }
}
public class CustomerTO
{
public object CustomerJson { get; set; }
}
From DAL I get CustomerJson value as below.
Customer.CustomerJson = {
"name": "Ram",
"city": "India"
}
I am in need to Deserialize this string. so I tried the below stuff while mapping.
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Customer, CustomerTO>()
.ForMember(dest => dest.CustName, opt => opt.MapFrom(src => JsonConvert.DeserializeObject(src.CustName)));
});
But this gives me run time error.
Unhandled Exception: AutoMapper.AutoMapperMappingException: Error mapping types.
So I kept it simple.
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Customer, CustomerTO>()
.ForMember(dest => dest.CustName, opt => opt.MapFrom(src => (src.CustName));
});
And I tried to deserialize it while consuming. But this give compile time error.
var custJson = JsonConvert.DeserializeObject(customerTO.CustomerJson );
Error 2 The best overloaded method match for 'Newtonsoft.Json.JsonConvert.DeserializeObject(string)' has some invalid arguments
I know customerTO.CustomerJson is not string but how do should I do the required mapping?
Thanks.
Based on your previous question and given the information above you seem to be confusing what you're trying to do here.
So I'm going to amalgamate the data from both in an attempt to solve the issues.
Entity Classes:
public class Customer
{
public int CustomerId {get; set; }
public string CustomerName { get; set; }
public string CustomerJson { get; set; }
}
public class CustomerTO
{
public int CustId { get; set; }
public object CustData { get; set; }
public object CustomerJson { get; set; }
}
AppMapper Class:
public static class AppMapper
{
public static MapperConfiguration Mapping()
{
return new MapperConfiguration(cfg =>
{
cfg.CreateMap<Customer, CustomerTO>()
.ForMember(dest => dest.CustId, opt => opt.MapFrom(src => src.CustomerId))
.ForMember(dest => dest.CustData, opt => opt.MapFrom(src => src.CustName))
.ForMember(dest => dest.CustomerJson, opt => opt.MapFrom(src => JsonConvert.DeserializeObject(src.CustomerJson));
});
}
}
Main:
public class Program
{
static void Main(string[] args)
{
var config = AppMapper.Mapping();
var mapper = config.CreateMapper();
// From Previous question get list of Customer objects
var customers = AddCustomers();
var mappedCustomers = mapper.Map<IEnumerable<CustomerTO>>(customers);
}
}
A couple of things to point out
I'm not sure what the purpose of CustData is in CustomerTO. It seems to be duplicating CustomerJson and if so remove it and the associated mapping.
Also, you never mention mapping from DTO back to entity, but for the JsonObject you just need to configure it to map the serialized string to the appropriate Property.
This is how I addressed my requirement.
Db Entity
public class Customer
{
public string CustomerData { get; set; }
// & other properties
}
My DTO
public class CustomerTO
{
public object CustomerData { get; set;}
// & other properties
}
I created a Utility like class with name AppMapper. This is how my AppMapper.cs looks like.
public class AppMapper
{
private IMapper _mapper;
public AppMapper()
{
var config = new MapperConfiguration(cfg =>
{
cfg.CreateMap<Customer, CustomerTO>();
//& other such mapping
});
_mapper = config.CreateMapper();
}
public CustomerTO Map(Customer customerEntity)
{
var customerTo= _mapper.Map<Customer,CustomerTO>(customerEntity);
return customerTo;
}
Now when I needed the mapping.
class DAL
{
public CustomerTO GetCustomers()
{
var customers= //LINQ To get customers
var customerTO = Mapping(customer);
return customerTO;
}
//However, this mapping glue in some internal class to retain SOLID principles
private CustomerTO Mapping(Customer custEntity)
{
var custTO = _appMapper.Map(custEntity);
var str = JsonConvert.Serialize(custTO.CustomerData);
custTO.CustomerData = JsonConvert.Deserialize(str);
return custTO;
}
}
That's it.
#Barry O'Kane - Sincere thanks for your inputs.
Points to be noted:-
I don't need to map manually any of the properites since the property name is same. Plus I am casting string to object. So no issues.
If you use .Map() for one property, then I found that I need to map each property else it gives default value of the data type.(Ex. for int it gives 0).
Yes. agreed there could be other method in Automapper which allows me specify that for a particulay property do this manual mapping & for rest use Automapping mechanism. But I am not sure on that.
Please feel free to improve this ans in any way.
Hope this helps :)