I have an ASP .Net core application. I am simply trying to have my AutoMapper configure to convert a string comma delimited into a list of strings as per this configuration:
configuration.CreateMap<Job, JobDto>()
.ForMember(dto => dto.Keywords, options => options.MapFrom(entity => entity.Keywords.Split(',').ToList()))
For some reason it does not get compiled and give me the following error:
An expression tree may not contain a call or invocation that uses
optional argument
I can't see why I am getting this error. I am pretty sure that I have done that in my other projects before without any such error.
As error says, Split function has an optional parameter. The full signature of it is as this (options is optional)
public string[] Split(string separator, StringSplitOptions options = StringSplitOptions.None)
As you are trying to use a function with default value inside an expression tree, it gives you the error.
To Fix it, easy, just pass on optional parameters by yourself. ( StringSplitOptions.None )
So, simply change it to this:
entity.Keywords.Split(',' , StringSplitOptions.None).ToList()
This is completely true.
Error is raised because expression tree being created is about to contain some more complex logic, like .Split(',').ToList(), which is not an accessible property or method, only top-level reflected object properties and methods are supported (like in class MemberInfo).
Property chaining, deep-calls (.obj1property.obj2property), extension methods are not supported by the expression trees, like in this .ToList() call.
My solution was like this:
// Execute a custom function to the source and/or destination types after member mapping
configuration.CreateMap<Job, JobDto>()
.AfterMap((dto,jobDto)=>jobDto.Keywords = dto.Keywords.Split(',').ToList());
I had the same problem. I do not know if it is an issue or not. Anyway, I found a workaround.
CreateMap<Category, GetCategoryRest>()
.ForMember(dest => dest.Words,
opt => opt.MapFrom(src => ToWordsList(src.Words)));
private static List<string> ToWordsList(string words)
{
return string.IsNullOrWhiteSpace(words) ? new List<string>() : words.Split(",").ToList();
}
It is guaranteed that AutoMapper has always a List. Still, I'm confused. In my Startup.cs I define that AutoMapper allows null values for list.
Mapper.Initialize(cfg => {
cfg.AllowNullCollections = true;
}
Category.Words is a string.
GetCategoryRest.Words is a List<string>
AutoMapper Version: 8.1.1,
AutoMapper.Microsoft.DependencyInjection: 6.1.1
Use .AfterMap
CreateMap<src, dto>()
.ForMember(src =>src.Categories,options=> options.Ignore())
.AfterMap((src, dto) => { dto.Categories.AddRange(src.Categories.Split(",").ToList()); })
.ReverseMap()
.ForMember(src => src.Categories, option => option.MapFrom(dto => string.Join(",", dto.Categories)));
Related
After migration from an old version of AutoMapper (before 5) to version 9 there is one spot which causes headache. Old implementation:
.ForMember(a => a.Definition, o =>
{
o.Condition(s => s.TypeId == DocumentationType.Medication);
o.ResolveUsing((d, ctx) => ctx.Engine.Map<MedicationDefinitionContent>(d.Content.MedicationContentData));
})
which uses this extension method:
public static class MappingExtensions
{
public static void ResolveUsing<TType>(this IMemberConfigurationExpression<TType> expression, Func<TType, ResolutionContext, object> map)
{
expression.ResolveUsing(result => map((TType)result.Value, result.Context));
}
}
I fixed the first error that that IMemberConfigurationExpression needs 3 arguments, but then I learned that ResolutionContext does not contain a definition for engine anymore. I looked in the upgrade guide of version 5 and found that the ResolutionContext has been changed, but I do not understand how to fix this. The code seems to be pretty tricky. Can someone help, please?
#Lucian Bargaoanu
Ok, but the member "Definition" is the member wie map with MapFrom(s => s.Content.MedicationContentData). So different to the exception there is already a mapping. The member "Definition" is of type SerialisationHelper a helper class for Json stuff. It also has a mapping.
CreateMap<MedicationDefinitionContent, SerialisationHelper>()
.IgnoreAllUnmapped()
.AfterMap((s, t) => t.Write = s);
And MedicationDefinitionContent has a separate mapping.
CreateMap<MedicationContentData, MedicationDefinitionContent>()
MedicationDefinitionContent is annotated with [JsonObject(MemberSerialization.OptIn)]
so, a direct mapping from MedicationDefinitionContent to "Definition" does not work.
How you see I try to understand it, but maybe it needs more time.
I'm having some issues mapping two classes using the AutoMapper in version 11. The destination class has an indexer-property, which causes the issue.
Since Automapper 11, the indexer property is no longer automatically ignored.
For testing purposes I used three classes:
public class Source {}
public class Target {
public float this[int key]
{
get
{
return 0;
}
set
{
}
}
}
public class MapperProfile: Profile
{
public MapperProfile()
{
CreateMap<Source, Target>();
}
}
During startup I'm calling mapper.ConfigurationProvider.AssertConfigurationIsValid() to validate the configuration. This fails with an unmapped Item property.
While it is possible to ignore all properties starting with Item using
this.AddGlobalIgnore("Item")
inside the Profile, I'd rather not use such a general way to ignore it, especially since the first parameter is labeled propertyNameStartingWith - this would suggest to me, that other properties such as ItemWithSuffix might be ignored as well.
Another strategy I tried to employ is to use an explicit ignore on a property. Using the expression notation fails, due to compiler errors:
CreateMap<Source, Target>()
.ForMember(dest => dest[], opt => opt.Ignore())
.ReverseMap();
Adding an arbitrary index to the expression fails with another error, so that does not seem to be a viable solution as well:
CreateMap<Source, Target>()
.ForMember(dest => dest[0], opt => opt.Ignore())
.ReverseMap();
In this case the error notes, that we may not map to child property.
When using the member name syntax, there are some different errors.
CreateMap<Source, Target>()
.ForMember("Item", opt => opt.Ignore())
.ReverseMap();
In this case it fails with the following message:
Incorrect number of arguments supplied for call to method 'Double get_Item(Int32)' (Parameter 'property')
Using [] or Item[] fails with a missing property notification.
The last strategy I employed was using the ForAllMembers call. This succeeds, however, I'm wondering if there is a better solution to handle this logic which allows using a specific mapping logic for a single member.
CreateMap<Source, Target>()
.ForAllMembers(x =>
{
if (x.DestinationMember.Name == "Item")
{
x.Ignore();
}
});
I'm still trying to wrap my head around how automapper works. I have the EF Core query below, which I'd like to change to using automapper.
var query = from t in Context.Tririga.AsNoTracking()
let l = t.Building
let m = t.Owner
let o = m.Organization
where o.Active
select new MetricBadLabManagerByOrganizationDTO {
CampusName = l.CampusName,
Email = m.Email,
Name = m.Name,
OrgLevel3 = o.ThreeName,
OrgLevel4 = o.FourName,
OrgLevel5 = o.FiveName,
OrgLevel6 = o.SixName,
OrgLevel7 = o.SevenName,
Reason = m.Active == false ? "Inactive Employee" : "Invalid Employee",
SiteName = l.SiteName,
Wwid = m.Wwid
};
return await query.ToArrayAsync();
I'm not sure how to setup a mapper configuration to the DTO type because I can't just go from Tririga to MetricBadLabManagerByOrganizationDTO as it doesn't know how to go down the relationships.
Here is the Getting Started Guide from AutoMapper if you haven't gone through the documentation.
I've recently got a chance to work on a project that uses AutoMapper to translate between persistence models and domain models, and here would be how I set things up:
There are many ways to configure your mappings. I like the Profile Instances method:
using AutoMapper;
namespace Company.Product.Infrastructure.Mapping.AutoMapper
{
public class MappingProfile : Profile
{
public MappingProfile()
{
CreateMap<Tririga, MetricBadLabManagerByOrganizationDTO>()
.ForMember(dest => dest.CampusName,
opts => opts.MapFrom(src => src.Building.CampusName))
.ForMember(dest => dest.Email,
opts => opts.MapFrom(src => src.Owner.Email))
.ForMember(dest => dest.Name,
opts => opts.MapFrom(src => src.Owner.Name))
...
}
}
}
There is a whole section about flattening on AutoMapper documentation.
Just a note,
When you configure a source/destination type pair in AutoMapper, the configurator attempts to match properties and methods on the source type to properties on the destination type. If for any property on the destination type a property, method, or a method prefixed with “Get” does not exist on the source type, AutoMapper splits the destination member name into individual words (by PascalCase conventions).
So you might not need to define the rule for each single property you want to map, otherwise what's the point of using AutoMapper.
For example, if your MetricBadLabManagerByOrganizationDTO campus name were named as BuildingCampusName, AutoMapper would be smart enough to look for Building property on your source and see if there is a property called CampusName inside.
There are just lots of valuable information in AutoMapper documentation you can find and learn from, which is what I like!
I'm using AutoMapper 5.2. I currently have a mapping statement that looks as follows:
CreateMap<JeffreysOnline.Data.Customer, JeffreysOnline.Entities.Customer>()
.ForMember(s => s.CustomerWant, t => t.Ignore());
Both the Customer table and Customer entity have a field named BadChecks. In the database it's an int. I recently changed the type to a bool in my entity. AutoMapper is now giving me the following error:
Unable to create a map expression from Customer.BadChecks (System.Int16) to Customer.BadChecks (System.Boolean) Mapping types: Customer -> Customer JeffreysOnline.Data.Customer -> JeffreysOnline.Entities.Customer Type Map configuration: Customer -> Customer JeffreysOnline.Data.Customer -> JeffreysOnline.Entities.Customer Property: BadChecks
It seems AutoMapper doesn't know how to map from an int to a boolean. Is it possible for me to help AutoMapper with this?
It may be helpful to know that in my DAL, I'm using ProjectTo() to pass an IQueryable to another method that is attempting to access the data, and therefore the mapping is occurring (an error being generated). My DAL code looks like this:
return entityList.OrderBy(row => row.LastName).ProjectTo<Entities.Customer>();
Automapper 6.0.2 - works without any ForMember... null, 0 = false, values >= 1 are mapped to true.
In Automapper 6.0.2 - other way:
class nnnProfile : Profile
{
CreateMap<src, dst>()
.ForMember(d => d.Decision, opt => opt.ResolveUsing<CustomBoolResolver>());
}
Resolver:
public class CustomBoolResolver : IValueResolver<src, dst, bool>
{
public bool Resolve(src source, dst destination, bool destMember,
ResolutionContext context)
{
return source.Decision == 1;
}
}
but this is per Destination, so not much flexible.
According to this page:
http://taswar.zeytinsoft.com/automapper-mapping-objects-part-5-of-7-customresolver/
In past you could write a custom resolver with just Source and target type.
I don't think I would know how to map from int to a boolean.
If you do figure out how that should happen, you'll need to create a mapping from int to boolean.:
CreateMap<int, bool>().ProjectUsing(src => src != 0);
Completely guessing there. But since you're using ProjectTo, you'll need to use ProjectUsing so that the expression makes it allllll the way down to your DAL.
Remember, when using ProjectUsing, AutoMapper isn't actually executing the mapping. It's creating a LINQ "Select" expression that it passes down to your query provider (EF maybe?). So you'll need to make sure that whatever you use in your projection expression, EF can support translating that eventually into SQL.
I want to customise the way AutoMapper converts my types without losing the features already implemented by AutoMapper.
I could create a custom ITypeConverter instance but I can't see how to invoke the default behaviour.
Mapper.CreateMap<MyDomainObject, MyDto>
.ConvertUsing<MyTypeConverter>();
...
public class MyTypeConverter : TypeConverter<MyDomainObject, MyDto>
{
public MyDto ConvertCore(MyDomainObject source)
{
var result = // Do the default mapping.
// do my custom logic
return result
}
}
If I try to call var result = Mapper.Map<MyDto>(source) it gets into an infinite loop. I effectively want AutoMapper to do everything it normally would assuming there was no TypeConverter defined.
Any help greatly appreciated.
If you only want to customise some values on the destination object, then you're better off with a Custom Value Resolver - TypeConverters are designed to handle the whole conversion.
The doc page listed above will have enough to get you started: when you have implemented the CustomResolver you apply it like this, and AutoMapper will do the default mapping for the other properties:
Mapper.CreateMap<MyDomainObject, MyDto>()
.ForMember(dest => dest.TargetProperty,
opt => opt.ResolveUsing<CustomResolver>());