public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList<MemberInfo> resolvers, IMemberConfiguration parent )
{
string[] matches = DestinationMemberNamingConvention.SplittingExpression
.Matches(nameToSearch)
.Cast<Match>()
.Select(m => SourceMemberNamingConvention.ReplaceValue(m))
.ToArray();
MemberInfo matchingMemberInfo = null;
for (int i = 1; i <= matches.Length; i++)
{
NameSnippet snippet = CreateNameSnippet(matches, i);
matchingMemberInfo = parent.NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, snippet.First);
if (matchingMemberInfo != null)
{
resolvers.AddLast(matchingMemberInfo);
var details = options.CreateTypeDetails(matchingMemberInfo.GetMemberType());
var foundMatch = parent.MapDestinationPropertyToSource(options, details, destType, destMemberType, snippet.Second, resolvers);
if (!foundMatch)
resolvers.RemoveLast();
else
break;
}
}
return matchingMemberInfo != null;
}
public bool MapDestinationPropertyToSource(ProfileMap options, TypeDetails sourceType, Type destType, Type destMemberType, string nameToSearch, LinkedList<MemberInfo> resolvers, IMemberConfiguration parent = null)
{
if (string.IsNullOrEmpty(nameToSearch))
return true;
var matchingMemberInfo = NameMapper.GetMatchingMemberInfo(sourceType, destType, destMemberType, nameToSearch);
if (matchingMemberInfo != null)
resolvers.AddLast(matchingMemberInfo);
return matchingMemberInfo != null;
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression) =>
Call(null,
MapMethodInfo.MakeGenericMethod(sourceExpression.Type, destExpression.Type),
sourceExpression,
contextExpression);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var sourceElementType = TypeHelper.GetElementType(sourceExpression.Type);
var destElementType = TypeHelper.GetElementType(destExpression.Type);
var ifNullExpr = profileMap.AllowNullCollections
? (Expression)Constant(null, destExpression.Type)
: NewArrayBounds(destElementType, Constant(0));
var itemExpr = CollectionMapperExtensions.MapItemExpr(configurationProvider, profileMap, propertyMap, sourceExpression.Type, destExpression.Type, contextExpression, out ParameterExpression itemParam);
//var count = source.Count();
//var array = new TDestination[count];
//int i = 0;
//foreach (var item in source)
// array[i++] = newItemFunc(item, context);
//return array;
var countParam = Parameter(typeof(int), "count");
var arrayParam = Parameter(ifNullExpr.Type, "destinationArray");
var indexParam = Parameter(typeof(int), "destinationArrayIndex");
var actions = new List <Expression>();
var parameters = new List <ParameterExpression> {
countParam, arrayParam, indexParam
};
var countMethod = typeof(Enumerable)
.GetTypeInfo()
.DeclaredMethods
.Single(mi => mi.Name == "Count" && mi.GetParameters().Length == 1)
.MakeGenericMethod(sourceElementType);
actions.Add(Assign(countParam, Call(countMethod, sourceExpression)));
actions.Add(Assign(arrayParam, NewArrayBounds(destElementType, countParam)));
actions.Add(Assign(indexParam, Constant(0)));
actions.Add(ForEach(sourceExpression, itemParam,
Assign(ArrayAccess(arrayParam, PostIncrementAssign(indexParam)), itemExpr)
));
actions.Add(arrayParam);
var mapExpr = Block(parameters, actions);
// return (source == null) ? ifNullExpr : Map<TSourceElement, TDestElement>(source, context);
return(Condition(Equal(sourceExpression, Constant(null)), ifNullExpr, mapExpr));
}
public static Expression NullCheckSource(ProfileMap profileMap, Expression sourceParameter, Expression destinationParameter, Expression mapExpression, MemberMap memberMap)
{
var sourceType = sourceParameter.Type;
if (sourceType.IsValueType && !sourceType.IsNullableType())
{
return(mapExpression);
}
var destinationType = destinationParameter.Type;
var isCollection = destinationType.IsCollection();
var mustUseDestination = memberMap is { MustUseDestination : true };
var ifSourceNull = memberMap == null?
destinationParameter.IfNullElse(DefaultDestination(), ClearDestinationCollection()) :
mustUseDestination?ClearDestinationCollection() : DefaultDestination();
return(sourceParameter.IfNullElse(ifSourceNull, mapExpression));
Expression ClearDestinationCollection()
{
if (!isCollection)
{
return(destinationParameter);
}
MethodInfo clearMethod;
var destinationVariable = Variable(destinationParameter.Type, "collectionDestination");
Expression collection = destinationVariable;
if (destinationType.IsListType())
{
clearMethod = IListClear;
}
else
{
var destinationCollectionType = destinationType.GetICollectionType();
if (destinationCollectionType == null)
{
if (!mustUseDestination)
{
return(destinationParameter);
}
var destinationElementType = GetEnumerableElementType(destinationType);
destinationCollectionType = typeof(ICollection <>).MakeGenericType(destinationElementType);
collection = Convert(collection, destinationCollectionType);
}
clearMethod = destinationCollectionType.GetMethod("Clear");
}
return(Block(new[] { destinationVariable },
Assign(destinationVariable, destinationParameter),
Condition(ReferenceEqual(destinationVariable, Null), Empty, Expression.Call(collection, clearMethod)),
destinationVariable));
}
Expression DefaultDestination()
{
if ((isCollection && profileMap.AllowsNullCollectionsFor(memberMap)) || (!isCollection && profileMap.AllowsNullDestinationValuesFor(memberMap)))
{
return(destinationParameter.NodeType == ExpressionType.Default ? destinationParameter : Default(destinationType));
}
if (destinationType.IsArray)
{
var destinationElementType = destinationType.GetElementType();
var rank = destinationType.GetArrayRank();
return(rank == 1 ?
Expression.Call(ArrayEmptyMethod.MakeGenericMethod(destinationElementType)) :
NewArrayBounds(destinationElementType, Enumerable.Repeat(Zero, rank)));
}
return(ObjectFactory.GenerateConstructorExpression(destinationType));
}
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression)
{
var sourceType = sourceExpression.Type;
var sourceTypeEnum = ElementTypeHelper.GetEnumerationType(sourceType);
var toStringCall = Expression.Call(sourceExpression, typeof(object).GetDeclaredMethod("ToString"));
var switchCases = new List <SwitchCase>();
var enumNames = sourceTypeEnum.GetDeclaredMembers();
foreach (var memberInfo in enumNames.Where(x => x.IsStatic()))
{
var attribute = memberInfo.GetCustomAttribute(typeof(EnumMemberAttribute)) as EnumMemberAttribute;
if (attribute?.Value != null)
{
var switchCase = Expression.SwitchCase(Expression.Constant(attribute.Value),
Expression.Constant(Enum.ToObject(sourceTypeEnum, memberInfo.GetMemberValue(null))));
switchCases.Add(switchCase);
}
}
return(switchCases.Count > 0
? (Expression)Expression.Switch(sourceExpression, toStringCall, switchCases.ToArray())
: toStringCall);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=> MapCollectionExpression(configurationProvider, profileMap, propertyMap, sourceExpression, destExpression, contextExpression, IfNotNull, typeof(List <>),
MapItemExpr);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
Expression.Call(null,
MapMethodInfo.MakeGenericMethod(destExpression.Type),
sourceExpression,
Expression.Condition(
Expression.Equal(ExpressionFactory.ToObject(destExpression), Expression.Constant(null)),
DelegateFactory.GenerateConstructorExpression(destExpression.Type),
destExpression),
contextExpression,
Expression.Constant(profileMap));
public Expression MapExpression(IGlobalConfiguration configurationProvider, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression) => configurationProvider.MapExpression(profileMap, GetAssociatedTypes(sourceExpression.Type, destExpression.Type), sourceExpression, memberMap);
public static Expression GenerateConstructorExpression(Type type, ProfileMap configuration) =>
configuration.AllowNullDestinationValues
? GenerateConstructorExpression(type)
: GenerateNonNullConstructorExpression(type);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=>
CollectionMapperExtensions.MapCollectionExpression(configurationProvider, profileMap, propertyMap, sourceExpression, destExpression,
contextExpression, CollectionMapperExtensions.IfNotNull, typeof(Dictionary <,>), CollectionMapperExtensions.MapItemExpr);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
PropertyMap propertyMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
Condition(
Equal(ToObject(sourceExpression), Constant(null)),
Default(destExpression.Type),
ToType(
Call(ChangeTypeMethod, ToObject(sourceExpression),
Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type)),
destExpression.Type
));
public static Expression MapKeyPairValueExpr(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Type sourceType, Type destType, Expression contextParam, out ParameterExpression itemParam)
{
var sourceElementTypes = ElementTypeHelper.GetElementTypes(sourceType, ElementTypeFlags.BreakKeyValuePair);
var destElementTypes = ElementTypeHelper.GetElementTypes(destType, ElementTypeFlags.BreakKeyValuePair);
var typePairKey = new TypePair(sourceElementTypes[0], destElementTypes[0]);
var typePairValue = new TypePair(sourceElementTypes[1], destElementTypes[1]);
var sourceElementType = typeof(KeyValuePair <,>).MakeGenericType(sourceElementTypes);
itemParam = Parameter(sourceElementType, "item");
var destElementType = typeof(KeyValuePair <,>).MakeGenericType(destElementTypes);
var keyExpr = TypeMapPlanBuilder.MapExpression(configurationProvider, profileMap, typePairKey,
Property(itemParam, "Key"), contextParam, propertyMap);
var valueExpr = TypeMapPlanBuilder.MapExpression(configurationProvider, profileMap, typePairValue,
Property(itemParam, "Value"), contextParam, propertyMap);
var keyPair = New(destElementType.GetConstructors().First(), keyExpr, valueExpr);
return(keyPair);
}
public static Expression MapItemExpr(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Type sourceType, Type destType, Expression contextParam, out ParameterExpression itemParam)
{
var sourceElementType = ElementTypeHelper.GetElementType(sourceType);
var destElementType = ElementTypeHelper.GetElementType(destType);
itemParam = Parameter(sourceElementType, "item");
var typePair = new TypePair(sourceElementType, destElementType);
var itemExpr = TypeMapPlanBuilder.MapExpression(configurationProvider, profileMap, typePair, itemParam, contextParam,
propertyMap);
return(ToType(itemExpr, destElementType));
}
public static Expression MapCollectionExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression, Func <Expression, Expression> conditionalExpression, Type ifInterfaceType, MapItem mapItem)
{
var passedDestination = Variable(destExpression.Type, "passedDestination");
var condition = conditionalExpression(passedDestination);
var newExpression = Variable(passedDestination.Type, "collectionDestination");
var sourceElementType = ElementTypeHelper.GetElementType(sourceExpression.Type);
var itemExpr = mapItem(configurationProvider, profileMap, propertyMap, sourceExpression.Type, passedDestination.Type,
contextExpression, out ParameterExpression itemParam);
var destinationElementType = itemExpr.Type;
var destinationCollectionType = typeof(ICollection <>).MakeGenericType(destinationElementType);
if (!destinationCollectionType.IsAssignableFrom(destExpression.Type))
{
destinationCollectionType = typeof(IList);
}
var addMethod = destinationCollectionType.GetDeclaredMethod("Add");
var destination = propertyMap?.UseDestinationValue == true ? passedDestination : newExpression;
var addItems = ForEach(sourceExpression, itemParam, Call(destination, addMethod, itemExpr));
var mapExpr = Block(addItems, destination);
var ifNullExpr = profileMap.AllowNullCollections ? Constant(null, passedDestination.Type) : (Expression)newExpression;
var clearMethod = destinationCollectionType.GetDeclaredMethod("Clear");
var isSourceNull = sourceExpression.Type.IsValueType() ? (Expression)Constant(false) : Equal(sourceExpression, Constant(null));
var checkNull =
Block(new[] { newExpression, passedDestination },
Assign(passedDestination, destExpression),
IfThenElse(condition ?? Constant(false),
Block(Assign(newExpression, passedDestination), Call(newExpression, clearMethod)),
Assign(newExpression, passedDestination.Type.NewExpr(ifInterfaceType))),
Condition(isSourceNull, ToType(ifNullExpr, passedDestination.Type), ToType(mapExpr, passedDestination.Type))
);
if (propertyMap != null)
{
return(checkNull);
}
var elementTypeMap = configurationProvider.ResolveTypeMap(sourceElementType, destinationElementType);
if (elementTypeMap == null)
{
return(checkNull);
}
var checkContext = TypeMapPlanBuilder.CheckContext(elementTypeMap, contextExpression);
if (checkContext == null)
{
return(checkNull);
}
return(Block(checkContext, checkNull));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap,
Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
Expression <Func <DestinationType> > expr = () => new DestinationType();
return(expr.Body);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=>
CollectionMapperExtensions.MapCollectionExpression(configurationProvider, profileMap, propertyMap,
Call(MembersDictionaryMethodInfo, sourceExpression, Constant(profileMap)), destExpression, contextExpression, _ => null,
typeof(Dictionary <,>), CollectionMapperExtensions.MapKeyPairValueExpr);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=>
MapCollectionExpression(configurationProvider, profileMap, memberMap, sourceExpression, destExpression,
contextExpression, typeof(Dictionary <,>), MapItemExpr);
private static TDestination Map <TDestination>(StringDictionary source, TDestination destination, ResolutionContext context, ProfileMap profileMap)
{
var destTypeDetails = profileMap.CreateTypeDetails(typeof(TDestination));
var members = from name in source.Keys
join member in destTypeDetails.PublicWriteAccessors on name equals member.Name
select member;
object boxedDestination = destination;
foreach (var member in members)
{
var value = context.MapMember(member, source[member.Name], boxedDestination);
member.SetMemberValue(boxedDestination, value);
}
return((TDestination)boxedDestination);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var listType = typeof(List <>).MakeGenericType(ElementTypeHelper.GetElementType(destExpression.Type));
var list = MapCollectionExpression(configurationProvider, profileMap, memberMap, sourceExpression, Default(listType), contextExpression, typeof(List <>), MapItemExpr);
var dest = Variable(listType, "dest");
var ctor = destExpression.Type.GetDeclaredConstructors()
.First(ci => ci.GetParameters().Length == 1 && ci.GetParameters()[0].ParameterType.IsAssignableFrom(dest.Type));
return(Block(new[] { dest },
Assign(dest, list),
Condition(NotEqual(dest, Default(listType)),
New(ctor, dest),
Default(destExpression.Type))));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var listType = typeof(List <>).MakeGenericType(ElementTypeHelper.GetElementType(destExpression.Type));
var list = MapCollectionExpression(configurationProvider, profileMap, propertyMap, sourceExpression, Default(listType), contextExpression, _ => Constant(false), typeof(List <>), MapItemExpr);
var dest = Variable(listType, "dest");
return(Block(new[] { dest }, Assign(dest, list), Condition(NotEqual(dest, Default(listType)), New(destExpression.Type.GetDeclaredConstructors().First(), dest), Default(destExpression.Type))));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
return(Condition(
Equal(ToObject(sourceExpression), Constant(null)),
Default(destExpression.Type),
ToType(
Call(EnumParseMethod,
Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type),
Call(sourceExpression, sourceExpression.Type.GetDeclaredMethod("ToString")),
Constant(true)
),
destExpression.Type
)));
}
public static Expression MapExpression(this IGlobalConfiguration configurationProvider, ProfileMap profileMap, TypePair typePair, Expression sourceParameter,
MemberMap propertyMap = null, Expression destinationParameter = null)
{
destinationParameter ??= Default(typePair.DestinationType);
var typeMap = configurationProvider.ResolveTypeMap(typePair);
Expression mapExpression = null;
bool hasTypeConverter;
if (typeMap != null)
{
hasTypeConverter = typeMap.HasTypeConverter;
if (!typeMap.HasDerivedTypesToInclude)
{
typeMap.Seal(configurationProvider);
mapExpression = typeMap.MapExpression?.ConvertReplaceParameters(sourceParameter, destinationParameter);
}
}
else
{
hasTypeConverter = false;
var mapper = configurationProvider.FindMapper(typePair);
mapExpression = mapper?.MapExpression(configurationProvider, profileMap, propertyMap, sourceParameter, destinationParameter);
}
mapExpression ??= ContextMap(typePair, sourceParameter, destinationParameter, propertyMap);
if (!hasTypeConverter)
{
mapExpression = NullCheckSource(profileMap, sourceParameter, destinationParameter, mapExpression, propertyMap);
}
return(ToType(mapExpression, typePair.DestinationType));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap,
Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var notNull = NotEqual(destExpression, Constant(null));
var EquivalencyExpression = this.GetEquivalentExpression(TypeHelper.GetElementType(sourceExpression.Type), TypeHelper.GetElementType(destExpression.Type));
var map = Call(null,
MapMethodInfo.MakeGenericMethod(sourceExpression.Type, TypeHelper.GetElementType(sourceExpression.Type), destExpression.Type, TypeHelper.GetElementType(destExpression.Type)),
sourceExpression, destExpression, contextExpression, Constant(EquivalencyExpression));
var collectionMap = CollectionMapper.MapExpression(configurationProvider, profileMap, propertyMap, sourceExpression, destExpression, contextExpression);
return(Condition(notNull, map, Convert(collectionMap, destExpression.Type)));
}
public abstract Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var dictionaryTypes = ElementTypeHelper.GetElementTypes(destExpression.Type, ElementTypeFlags.BreakKeyValuePair);
var dictType = typeof(Dictionary <,>).MakeGenericType(dictionaryTypes);
var dict = MapCollectionExpression(configurationProvider, profileMap, memberMap, sourceExpression, Default(dictType), contextExpression, typeof(Dictionary <,>), MapKeyPairValueExpr);
var dest = Variable(dictType, "dest");
var readOnlyDictType = destExpression.Type.IsInterface
? typeof(ReadOnlyDictionary <,>).MakeGenericType(dictionaryTypes)
: destExpression.Type;
var ctor = readOnlyDictType.GetDeclaredConstructors()
.First(ci => ci.GetParameters().Length == 1 && ci.GetParameters()[0].ParameterType.IsAssignableFrom(dest.Type));
return(Block(new[] { dest },
Assign(dest, dict),
Condition(NotEqual(dest, Default(dictType)),
ToType(New(ctor, dest), destExpression.Type),
Default(destExpression.Type))));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=> MapCollectionExpression(configurationProvider, profileMap, memberMap,
Call(MembersDictionaryMethodInfo, sourceExpression, Constant(profileMap)), destExpression, contextExpression, typeof(Dictionary <,>),
MapKeyPairValueExpr);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression) => MapCollectionExpression(configurationProvider, profileMap, propertyMap, sourceExpression, destExpression, contextExpression, IfNotNull, typeof(Dictionary <,>), MapKeyPairValueExpr);
public override Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
=> CollectionMapperExpressionFactory.MapCollectionExpression(configurationProvider, profileMap, memberMap, sourceExpression, destExpression, contextExpression, typeof(List <>), CollectionMapperExpressionFactory.MapItemExpr);
public override Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap, PropertyMap propertyMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
if (destExpression.Type.IsInterface())
{
var listType = typeof(IList <>).MakeGenericType(ElementTypeHelper.GetElementType(destExpression.Type));
destExpression = Convert(destExpression, listType);
}
return(MapCollectionExpression(configurationProvider, profileMap, propertyMap, sourceExpression,
destExpression, contextExpression, typeof(List <>), MapItemExpr));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var implicitOperator = GetImplicitConversionOperator(new TypePair(sourceExpression.Type, destExpression.Type));
return Expression.Call(null, implicitOperator, sourceExpression);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
PropertyMap propertyMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
Call(null,
MapMethodInfo.MakeGenericMethod(destExpression.Type, sourceExpression.Type,
TypeHelper.GetElementType(sourceExpression.Type)),
sourceExpression,
contextExpression,
Constant(profileMap));
