We Keep Coding

AutoMapper - Apply ForAllMembers instead of multiple ForMembers

I'm kind of new in the world of AutoMapper, just so you know =)
I have 2 classes:
Class LibraryParameters
public class LibraryParameters
{
public int library_id { get; set; }
public string document_name { get; set; } = string.Empty;
public string template_name { get; set; } = string.Empty;
}
Class LibraryDocument
public class LibraryDocument
{
public int libraryId { get; set; }
public string documentName { get; set; } = string.Empty;
public string templateName { get; set; } = string.Empty;
}
So as you can see the variable names are different. So I use AutoMapper for this problem. I configured AutoMapper and made use of .ForMember as you can see below:
CreateMap<LibraryParameters, LibraryDocument>()
.ForMember(dest => dest.libraryId,
opt => opt.MapFrom(src => src.library_id))
.ForMember(dest => dest.templateName,
opt => opt.MapFrom(src => src.template_name))
.ForMember(dest => dest.documentName,
opt => opt.MapFrom(src => src.document_name));
But is it not possible to avoid these different ForMember methods and use ForAllMembers for example? I can't find any information about this anywhere so you guys are my source of help :)

Instead of using .ForAllMembers(), you need to specify the naming convention for the source as below:
For MapperConfiguration
MapperConfiguration _config = new MapperConfiguration(cfg => {
cfg.SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
});
For Mapping Profile
public class YourProfile : Profile
{
public YourProfile()
{
SourceMemberNamingConvention = new LowerUnderscoreNamingConvention();
}
}
Demo # .NET Fiddle
References
Naming Conventions | AutoMapper

Automapper. How to map custom type property of inner class (source) to string and string array?

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);
});

Automapper Map multiple optional properties to list

I have a class OrderLineRequest that I want to map to an OrderLine class with a list of barcodes. The properties Barcode1,2,3 needs to be mapped to Barcodes only if the contain a value. Barcode1 is always filled, Barcode2 and Barcode3 are optional. I have created a mapping but this gives me always 3 barcodes in the list. If Barcode1 or 2 is an empty string i don't want to add them to the list. How can i do this?
public class OrderLineRequest
{
public string OrderLineId { get; set; }
public string Barcode1 { get; set; }
public string Barcode2 { get; set; }
public string Barcode3 { get; set; }
public int Quantity { get; set; }
}
public class OrderLine
{
public int Id { get;set;}
public int OrderId { get;set;}
public string OrderLineNumber { get; set; }
public int Qty { get; set; }
public List<Barcode> Barcodes { get;set;}
}
public class Barcode
{
public int Id { get;set;}
public int OrderLineId { get;set;}
public string Code { get;set;}
}
CreateMap<OrderLineRequest, OrderLine>()
.ForMember(b => b.Id, e => e.Ignore())
.ForMember(d => d.OrderId, p => p.Ignore())
.ForMember(d => d.OrderLineNumber, p => p.MapFrom(s => s.OrderLineId))
.ForMember(d => d.Qty, p => p.MapFrom(s => s.Quantity))
.ForMember(d => d.BarCodes, p => p.MapFrom(s => new List<EanCode>() { new EanCode(){Code = s.Barcode1}, new EanCode() { Code = s.Barcode2 }, new EanCode() { Code = s.Barcode3 } }));

Why are you always creating those three barcodes?
I would suggest you to create a function for the predicate
that accepts OrderLineRequest and returns your List and handle the creation within the function. Like that:
private List<EanCode> Foo(OrderLineRequest orderLineRequest)
{
var result = new List<EanCode>();
if(!string.IsNullOrEmpty(orderLineRequest.Barcode1)
result.Add(new EanCode {Code = orderLineRequest.Barcode1});
//...
return result;
}
And then you could use it like:
.ForMember(d => d.BarCodes, p => p.MapFrom(s => Foo(s)));

If you're using Automapper, the step of adding three specific properties from the source to a list in the destination can't be accomplished with a simple function. You have to tell Automapper how to accomplish it.
You can do that by telling it to ignore those properties during the initial mapping, and then add items to the destination list after that mapping is complete.
For brevity this includes only those properties:
var configuration = new MapperConfiguration(
cfg => cfg.CreateMap<OrderLineRequest, OrderLine>()
.ForMember(d => d.Barcodes, opt => opt.Ignore())
.ForSourceMember(s => s.Barcode1, opt => opt.DoNotValidate())
.ForSourceMember(s => s.Barcode2, opt => opt.DoNotValidate())
.ForSourceMember(s => s.Barcode3, opt => opt.DoNotValidate())
.AfterMap((source, destination) =>
{
destination.Barcodes = new List<Barcode>
{
new Barcode { Code = source.Barcode1 }
};
if (source.Barcode2 != null)
destination.Barcodes.Add(new Barcode { Code = source.Barcode2 });
if (source.Barcode3 != null)
destination.Barcodes.Add(new Barcode { Code = source.Barcode3 });
}));
It could be said that this makes a case for just writing your own extension instead of using Automapper. It's convenient when the mapping is simple, but if it's not then using it could arguably be more trouble than it's worth. That's a matter of preference.

Create an array of the three properties. Once it's in an array, you can use Where to remove the nulls and Select to instantiate the EanCode instances. Once the data are in good shape, call ToList().
.ForMember
(
d => d.BarCodes,
p => p.MapFrom
(
s =>
(new [] { s.BarCode1, s.BarCode2, s.BarCode3 })
.Where( x => x != null)
.Select( x => new EanCode { Code = x } )
.ToList()
)
);

Can AutoMapper mappings be composed?

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?

AutoMapper: Unflattening to constructor

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);
}