public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression)
{
var destinationType = destExpression.Type;
var destinationEnumType = ElementTypeHelper.GetEnumerationType(destinationType);
var enumParse = Expression.Call(typeof(Enum), "Parse", null, Expression.Constant(destinationEnumType),
sourceExpression, Expression.Constant(true));
var switchCases = new List <SwitchCase>();
var enumNames = destinationEnumType.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(
ToType(Expression.Constant(Enum.ToObject(destinationEnumType, memberInfo.GetMemberValue(null))),
destinationType), Expression.Constant(attribute.Value));
switchCases.Add(switchCase);
}
}
var equalsMethodInfo = Method(() => StringCompareOrdinalIgnoreCase(null, null));
var switchTable = switchCases.Count > 0
? Expression.Switch(sourceExpression, ToType(enumParse, destinationType), equalsMethodInfo, switchCases)
: ToType(enumParse, destinationType);
var isNullOrEmpty = Expression.Call(typeof(string), "IsNullOrEmpty", null, sourceExpression);
return(Expression.Condition(isNullOrEmpty, Expression.Default(destinationType), switchTable));
}
public static Expression ContextMap(TypePair typePair, Expression sourceParameter, Expression contextParameter,
Expression destinationParameter, IMemberMap memberMap)
{
var mapMethod = ContextMapMethod.MakeGenericMethod(typePair.SourceType, typePair.DestinationType);
return(Call(contextParameter, mapMethod, sourceParameter, destinationParameter, Constant(memberMap, typeof(IMemberMap))));
}
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));
}
private ExpressionResolutionResult ResolveExpression(IMemberMap propertyMap, Type currentType, Expression instanceParameter, LetPropertyMaps letPropertyMaps)
{
var result = new ExpressionResolutionResult(instanceParameter, currentType);
var matchingExpressionConverter = _configurationProvider.ResultConverters.FirstOrDefault(c => c.CanGetExpressionResolutionResult(result, propertyMap));
if (matchingExpressionConverter == null)
{
ThrowCannotMap(propertyMap, result);
return(null);
}
result = matchingExpressionConverter.GetExpressionResolutionResult(result, propertyMap, letPropertyMaps);
if (propertyMap.NullSubstitute != null && result.Type.IsNullableType())
{
var currentChild = result.ResolutionExpression;
var currentChildType = result.Type;
var nullSubstitute = propertyMap.NullSubstitute;
var newParameter = result.ResolutionExpression;
var converter = new NullSubstitutionConversionVisitor(newParameter, nullSubstitute);
currentChild = converter.Visit(currentChild);
currentChildType = currentChildType.GetTypeOfNullable();
return(new ExpressionResolutionResult(currentChild, currentChildType));
}
return(result);
}
public ExpressionResolutionResult GetExpressionResolutionResult(
ExpressionResolutionResult expressionResolutionResult, IMemberMap propertyMap, LetPropertyMaps letPropertyMaps)
{
var mapFrom = propertyMap.CustomMapExpression;
if (!IsSubQuery() || letPropertyMaps.ConfigurationProvider.ResolveTypeMap(propertyMap.SourceType, propertyMap.DestinationType) == null)
{
return(new ExpressionResolutionResult(mapFrom.ReplaceParameters(propertyMap.CheckCustomSource(expressionResolutionResult, letPropertyMaps))));
}
if (propertyMap.CustomSource == null)
{
return(new ExpressionResolutionResult(letPropertyMaps.GetSubQueryMarker(mapFrom), mapFrom));
}
var newMapFrom = Lambda(mapFrom.ReplaceParameters(propertyMap.CustomSource.Body), propertyMap.CustomSource.Parameters);
return(new ExpressionResolutionResult(letPropertyMaps.GetSubQueryMarker(newMapFrom), newMapFrom));
bool IsSubQuery()
{
if (!(mapFrom.Body is MethodCallExpression methodCall))
{
return(false);
}
var method = methodCall.Method;
return(method.IsStatic && method.DeclaringType == typeof(Enumerable));
}
}
public MapRequest(TypePair requestedTypes, TypePair runtimeTypes, ITypeMapConfiguration inlineConfig, IMemberMap memberMap = null)
{
RequestedTypes = requestedTypes;
RuntimeTypes = runtimeTypes;
InlineConfig = inlineConfig;
MemberMap = memberMap;
}
public static Expression NullCheckSource(ProfileMap profileMap,
Expression sourceParameter,
Expression destinationParameter,
Expression objectMapperExpression,
IMemberMap memberMap)
{
var declaredDestinationType = destinationParameter.Type;
var destinationType = objectMapperExpression.Type;
var defaultDestination = DefaultDestination(destinationType, declaredDestinationType, profileMap);
var destination = memberMap == null
? destinationParameter.IfNullElse(defaultDestination, destinationParameter)
: memberMap.UseDestinationValue.GetValueOrDefault() ? destinationParameter : defaultDestination;
var ifSourceNull = destinationParameter.Type.IsCollectionType() ? ClearDestinationCollection() : destination;
return(sourceParameter.IfNullElse(ifSourceNull, objectMapperExpression));
Expression ClearDestinationCollection()
{
var destinationElementType = ElementTypeHelper.GetElementType(destinationParameter.Type);
var destinationCollectionType = typeof(ICollection <>).MakeGenericType(destinationElementType);
var destinationVariable = Variable(destinationCollectionType, "collectionDestination");
var clear = Call(destinationVariable, destinationCollectionType.GetDeclaredMethod("Clear"));
var isReadOnly = Property(destinationVariable, "IsReadOnly");
return(Block(new[] { destinationVariable },
Assign(destinationVariable, ExpressionFactory.ToType(destinationParameter, destinationCollectionType)),
Condition(OrElse(Equal(destinationVariable, Constant(null)), isReadOnly), Empty(), clear),
destination));
}
}
private static object PrimaryParameter(IMemberMap member)
{
return(new
{
member.Ssn,
});
}
private ValidationContext(TypePair types, IMemberMap memberMap, IObjectMapper objectMapper, TypeMap typeMap)
{
ObjectMapper = objectMapper;
TypeMap = typeMap;
Types = types;
MemberMap = memberMap;
}
public static EventBrokerResolvedType ResolveType(IMemberMap<EventInfo> memberMap, TypeBuilder typeBuilder)
{
Type[] @params = null;
Type delegateType = null;
Type[] delegateParameters = null;
var @event = memberMap.ContractMember;
var declaringType = memberMap.ContractType;
var invokeMethod = @event.GetInvokeMethod();
var invokeReturnType = invokeMethod.ReturnType;
var eventBrokerResolvedType = new EventBrokerResolvedType(@event) {
DecalringType = declaringType
};
if (invokeMethod.GetDelegateParams(out @params, out delegateParameters)) {
delegateType = @params.GetDelegateType(true);
eventBrokerResolvedType.EventInterceptionContractArgs = @event.ToEventArgumentContract(@params);
eventBrokerResolvedType.EventInterceptionArgs = declaringType.MakeGenericFunctionAspectArgsEvent(@params);
eventBrokerResolvedType.EventBrokerBaseClassType = declaringType.MakeGenericEventBrokerBaseClassFunctionBinding(@params);
eventBrokerResolvedType.EventBrokerInvokeDelegateType = typeof(Func<,>).MakeGenericType(new[] { eventBrokerResolvedType.EventInterceptionContractArgs, invokeReturnType });
}
else {
delegateType = delegateParameters.GetDelegateType(false);
eventBrokerResolvedType.EventInterceptionContractArgs = @event.ToEventArgumentContract(delegateParameters);
eventBrokerResolvedType.EventInterceptionArgs = declaringType.MakeGenericActionAspectArgsEvent(delegateParameters);
eventBrokerResolvedType.EventBrokerBaseClassType = declaringType.MakeGenericEventBrokerBaseClassActionType(delegateParameters);
eventBrokerResolvedType.EventBrokerInvokeDelegateType = typeof(Action<>).MakeGenericType(new[] { eventBrokerResolvedType.EventInterceptionContractArgs });
}
eventBrokerResolvedType.Arguments = delegateParameters;
eventBrokerResolvedType.EventBrokerFieldType = typeof(IEventBroker<>).MakeGenericType(delegateType);
return eventBrokerResolvedType;
}
private static void ThrowCannotMap(IMemberMap propertyMap, ExpressionResolutionResult result)
{
var message =
$"Unable to create a map expression from {propertyMap.SourceMember?.DeclaringType?.Name}.{propertyMap.SourceMember?.Name} ({result.Type}) to {propertyMap.DestinationType.Name}.{propertyMap.DestinationName} ({propertyMap.DestinationType})";
throw new AutoMapperMappingException(message, null, propertyMap.TypeMap.Types, propertyMap.TypeMap, propertyMap);
}
public static Parameter GetParameter(Type entityType, ISqlGenerator sqlGenerator, string propertyName, object value)
{
IClassMapper map = sqlGenerator.Configuration.GetMap(entityType);
if (map == null)
{
throw new NullReferenceException(String.Format("Map was not found for {0}", entityType));
}
IMemberMap propertyMap = map.Properties.SingleOrDefault(p => p.Name == propertyName);
if (propertyMap == null)
{
throw new NullReferenceException(String.Format("{0} was not found for {1}", propertyName, entityType));
}
return(new Parameter
{
ColumnName = propertyMap.ColumnName,
DbType = propertyMap.DbType,
ParameterDirection = propertyMap.DbDirection,
Precision = propertyMap.DbPrecision,
Scale = propertyMap.DbScale,
Size = propertyMap.DbSize,
Value = value is Func <object>?(value as Func <object>).Invoke() : value,
Name = propertyName
});
}
public static Expression MapExpression(IConfigurationProvider configurationProvider,
ProfileMap profileMap,
TypePair typePair,
Expression sourceParameter,
Expression contextParameter,
IMemberMap propertyMap = null, Expression destinationParameter = null)
{
if (destinationParameter == null)
{
destinationParameter = Default(typePair.DestinationType);
}
var typeMap = configurationProvider.ResolveTypeMap(typePair);
if (typeMap != null)
{
if (!typeMap.HasDerivedTypesToInclude())
{
typeMap.Seal(configurationProvider);
return(typeMap.MapExpression != null
? typeMap.MapExpression.ConvertReplaceParameters(sourceParameter, destinationParameter,
contextParameter)
: ContextMap(typePair, sourceParameter, contextParameter, destinationParameter, propertyMap));
}
return(ContextMap(typePair, sourceParameter, contextParameter, destinationParameter, propertyMap));
}
var objectMapperExpression = ObjectMapperExpression(configurationProvider, profileMap, typePair,
sourceParameter, contextParameter, propertyMap, destinationParameter);
var nullCheckSource = NullCheckSource(profileMap, sourceParameter, destinationParameter, objectMapperExpression, propertyMap);
return(ExpressionFactory.ToType(nullCheckSource, typePair.DestinationType));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
var typeMap = new TypePair(sourceExpression.Type, destExpression.Type);
return(_converters[typeMap].Value.ReplaceParameters(sourceExpression));
}
internal void Add(XName name, IMemberMap <T> map)
{
if (_list.ContainsKey(name))
{
throw new MappingException("'{0}' has been already mapped.".F(name));
}
_list.Add(name, map);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap,
Expression sourceExpression, Expression destExpression, Expression contextExpression)
{
Expression <Func <DestinationType> > expr = () => new DestinationType();
return(expr.Body);
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
Call(null,
MapMethodInfo.MakeGenericMethod(destExpression.Type, sourceExpression.Type,
ElementTypeHelper.GetElementType(sourceExpression.Type)),
sourceExpression,
contextExpression);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
ExpressionFactory.ToType(
Expression.Call(ChangeTypeMethod, ExpressionFactory.ToObject(sourceExpression),
Expression.Constant(destExpression.Type)),
destExpression.Type
);
void IElementContentContainer <T> .SetElementContentMap(IMemberMap <T> map)
{
if (_contentMap != null)
{
throw new MappingException("Element content is mapped more than once in {0}.", this.GetType().Name);
}
_contentMap = map;
}
public Column(string columnNameAlias, IMemberMap property, IClassMapper classMapper, Table table)
{
Alias = columnNameAlias;
ClassMapper = classMapper;
Property = property;
TableIdentity = table.Identity;
Table = table;
}
public Func <TSource, TDestination, ResolutionContext, TDestination> GetMapperFunc <TSource, TDestination>(
TypePair types, IMemberMap memberMap = null)
{
var key = new TypePair(typeof(TSource), typeof(TDestination));
var mapRequest = new MapRequest(key, types, memberMap);
return(GetMapperFunc <TSource, TDestination>(mapRequest));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
ToType(
Call(EnumToObject, Constant(destExpression.Type),
ToObject(sourceExpression)),
destExpression.Type
);
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");
return(Block(new[] { dest }, Assign(dest, list), Condition(NotEqual(dest, Default(listType)), New(destExpression.Type.GetDeclaredConstructors().First(), dest), Default(destExpression.Type))));
}
public object Map(object source, object destination, Type sourceType, Type destinationType,
ResolutionContext context, IMemberMap memberMap)
{
var types = TypePair.Create(source, destination, sourceType, destinationType);
var func = ConfigurationProvider.GetUntypedMapperFunc(new MapRequest(new TypePair(sourceType, destinationType), types, memberMap));
return(func(source, destination, context));
}
public TDestination Map <TSource, TDestination>(TSource source, TDestination destination,
ResolutionContext context, IMemberMap memberMap)
{
var types = TypePair.Create(source, destination, typeof(TSource), typeof(TDestination));
var func = ConfigurationProvider.GetMapperFunc <TSource, TDestination>(types, memberMap);
return(func(source, destination, context));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
ExpressionBuilder.MapExpression(configurationProvider, profileMap,
new TypePair(sourceExpression.Type, Nullable.GetUnderlyingType(destExpression.Type)),
sourceExpression,
contextExpression,
memberMap
);
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
ExpressionBuilder.MapExpression(configurationProvider, profileMap,
new TypePair(Nullable.GetUnderlyingType(sourceExpression.Type), destExpression.Type),
Property(sourceExpression, sourceExpression.Type.GetDeclaredProperty("Value")),
contextExpression,
memberMap,
destExpression
);
public static Expression CheckCustomSource(this IMemberMap memberMap, ExpressionResolutionResult expressionResolutionResult, LetPropertyMaps letPropertyMaps)
{
if (memberMap.CustomSource == null)
{
return(expressionResolutionResult.ResolutionExpression);
}
return(memberMap.CustomSource.IsMemberPath() ?
memberMap.CustomSource.ReplaceParameters(expressionResolutionResult.ResolutionExpression) :
letPropertyMaps.GetSubQueryMarker(memberMap.CustomSource));
}
public virtual string GetColumnName(IClassMapper map, string propertyName, bool includeAlias)
{
IMemberMap propertyMap = map.Properties.SingleOrDefault(p => p.Name.Equals(propertyName, StringComparison.InvariantCultureIgnoreCase));
if (propertyMap == null)
{
throw new ArgumentException(string.Format("Could not find '{0}' in Mapping.", propertyName));
}
return(GetColumnName(map, propertyMap, includeAlias));
}
public virtual string GetColumnName(IClassMapper map, IMemberMap property, bool includeAlias)
{
string alias = null;
if (property.ColumnName != property.Name && includeAlias)
{
alias = property.Name;
}
return(Configuration.Dialect.GetColumnName(GetTableName(map), property.ColumnName, alias));
}
public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
IMemberMap memberMap, Expression sourceExpression, Expression destExpression,
Expression contextExpression) =>
ExpressionFactory.ToType(
Expression.Call(EnumParseMethod,
Expression.Constant(destExpression.Type),
Expression.Call(sourceExpression, sourceExpression.Type.GetDeclaredMethod("ToString", new Type[0])),
Expression.Constant(true)
),
destExpression.Type
);
