public TypeMap CreateClosedGenericTypeMap(ITypeMapConfiguration openMapConfig, TypeMapRegistry typeMapRegistry, TypePair closedTypes)
{
var closedMap = _typeMapFactory.CreateTypeMap(closedTypes.SourceType, closedTypes.DestinationType, this);
openMapConfig.Configure(closedMap);
Configure(typeMapRegistry, closedMap);
if (closedMap.TypeConverterType != null)
{
var typeParams =
(openMapConfig.SourceType.IsGenericTypeDefinition() ? closedTypes.SourceType.GetGenericArguments() : new Type[0])
.Concat
(openMapConfig.DestinationType.IsGenericTypeDefinition() ? closedTypes.DestinationType.GetGenericArguments() : new Type[0]);
var neededParameters = closedMap.TypeConverterType.GetGenericParameters().Length;
closedMap.TypeConverterType = closedMap.TypeConverterType.MakeGenericType(typeParams.Take(neededParameters).ToArray());
}
if (closedMap.DestinationTypeOverride?.IsGenericTypeDefinition() == true)
{
var neededParameters = closedMap.DestinationTypeOverride.GetGenericParameters().Length;
closedMap.DestinationTypeOverride = closedMap.DestinationTypeOverride.MakeGenericType(closedTypes.DestinationType.GetGenericArguments().Take(neededParameters).ToArray());
}
return(closedMap);
}
private TypeMap GetCachedMap(TypePair initialTypes, TypePair types) => (types != initialTypes && _typeMapPlanCache.TryGetValue(types, out var typeMap)) ? typeMap : null;
public TypeMap FindTypeMapFor(Type sourceType, Type destinationType)
{
var typePair = new TypePair(sourceType, destinationType);
return(FindTypeMapFor(typePair));
}
public LambdaExpression BuildExecutionPlan(Type sourceType, Type destinationType)
{
var typePair = new TypePair(sourceType, destinationType);
return(BuildExecutionPlan(new MapRequest(typePair, typePair)));
}
public TypeMap ResolveTypeMap(Type sourceType, Type destinationType, ITypeMapConfiguration inlineConfiguration)
{
var typePair = new TypePair(sourceType, destinationType);
return(ResolveTypeMap(typePair, inlineConfiguration));
}
public ResolutionContext(object source, object destination, TypePair types, ResolutionContext parent) : this(parent)
{
SourceValue = source;
DestinationValue = destination;
Types = types;
}
internal void DecrementTypeDepth(TypePair types)
{
TypeDepth[types]--;
}
public ValidationContext(TypePair types, PropertyMap propertyMap, IObjectMapper objectMapper) : this(types, propertyMap, objectMapper, null)
{
}
public ValidationContext(TypePair types, PropertyMap propertyMap, TypeMap typeMap) : this(types, propertyMap, null, typeMap)
{
}
public TypeMap CreateClosedGenericTypeMap(ITypeMapConfiguration openMapConfig, TypePair closedTypes, IConfigurationProvider configurationProvider)
{
var closedMap = TypeMapFactory.CreateTypeMap(closedTypes.SourceType, closedTypes.DestinationType, this);
closedMap.IsClosedGeneric = true;
openMapConfig.Configure(closedMap);
Configure(closedMap, configurationProvider);
if (closedMap.TypeConverterType != null)
{
var typeParams =
(openMapConfig.SourceType.IsGenericTypeDefinition ? closedTypes.SourceType.GetGenericArguments() : Type.EmptyTypes)
.Concat
(openMapConfig.DestinationType.IsGenericTypeDefinition ? closedTypes.DestinationType.GetGenericArguments() : Type.EmptyTypes);
var neededParameters = closedMap.TypeConverterType.GetGenericParameters().Length;
closedMap.TypeConverterType = closedMap.TypeConverterType.MakeGenericType(typeParams.Take(neededParameters).ToArray());
}
if (closedMap.DestinationTypeOverride?.IsGenericTypeDefinition == true)
{
var neededParameters = closedMap.DestinationTypeOverride.GetGenericParameters().Length;
closedMap.DestinationTypeOverride = closedMap.DestinationTypeOverride.MakeGenericType(closedTypes.DestinationType.GetGenericArguments().Take(neededParameters).ToArray());
}
return(closedMap);
}
private static LambdaExpression TryCatch(LambdaExpression mapExpression, ParameterExpression source, ParameterExpression destination, ParameterExpression context, TypePair types)
{
var exception = Parameter(typeof(Exception), "ex");
return(Lambda(Expression.TryCatch(mapExpression.Body,
MakeCatchBlock(typeof(Exception), exception, Block(
Throw(New(ExceptionConstructor, Constant("Error mapping types."), exception, Constant(types))),
Default(destination.Type)), null)),
source, destination, context));
}
public MapRequest(TypePair requestedTypes, TypePair runtimeTypes)
{
RequestedTypes = requestedTypes;
RuntimeTypes = runtimeTypes;
_hashcode = unchecked (RequestedTypes.GetHashCode() * 397) ^ RuntimeTypes.GetHashCode();
}
public bool IsConventionMap(TypePair types) => TypeConfigurations.Any(c => c.IsMatch(types));
private void Seal(IConfiguration configuration)
{
ServiceCtor = configuration.ServiceCtor;
AllowNullDestinationValues = configuration.AllowNullDestinationValues;
AllowNullCollections = configuration.AllowNullCollections;
var derivedMaps = new List <Tuple <TypePair, TypeMap> >();
var redirectedTypes = new List <Tuple <TypePair, TypePair> >();
foreach (var profile in configuration.Profiles.Cast <IProfileConfiguration>())
{
profile.Register(_typeMapRegistry);
}
foreach (var action in configuration.AllTypeMapActions)
{
foreach (var typeMap in _typeMapRegistry.TypeMaps)
{
var expression = new MappingExpression(typeMap.Types, typeMap.ConfiguredMemberList);
action(typeMap, expression);
expression.Configure(typeMap.Profile, typeMap);
}
}
foreach (var action in configuration.AllPropertyMapActions)
{
foreach (var typeMap in _typeMapRegistry.TypeMaps)
{
foreach (var propertyMap in typeMap.GetPropertyMaps())
{
var memberExpression = new MappingExpression.MemberConfigurationExpression(propertyMap.DestinationProperty, typeMap.SourceType);
action(propertyMap, memberExpression);
memberExpression.Configure(typeMap);
}
}
}
foreach (var profile in configuration.Profiles.Cast <IProfileConfiguration>())
{
profile.Configure(_typeMapRegistry);
}
foreach (var typeMap in _typeMapRegistry.TypeMaps)
{
_typeMapPlanCache[typeMap.Types] = typeMap;
if (typeMap.DestinationTypeOverride != null)
{
redirectedTypes.Add(Tuple.Create(typeMap.Types, new TypePair(typeMap.SourceType, typeMap.DestinationTypeOverride)));
}
if (typeMap.SourceType.IsNullableType())
{
var nonNullableTypes = new TypePair(Nullable.GetUnderlyingType(typeMap.SourceType), typeMap.DestinationType);
redirectedTypes.Add(Tuple.Create(nonNullableTypes, typeMap.Types));
}
derivedMaps.AddRange(GetDerivedTypeMaps(typeMap).Select(derivedMap => Tuple.Create(new TypePair(derivedMap.SourceType, typeMap.DestinationType), derivedMap)));
}
foreach (var redirectedType in redirectedTypes)
{
var derivedMap = FindTypeMapFor(redirectedType.Item2);
if (derivedMap != null)
{
_typeMapPlanCache[redirectedType.Item1] = derivedMap;
}
}
foreach (var derivedMap in derivedMaps.Where(derivedMap => !_typeMapPlanCache.ContainsKey(derivedMap.Item1)))
{
_typeMapPlanCache[derivedMap.Item1] = derivedMap.Item2;
}
foreach (var typeMap in _typeMapRegistry.TypeMaps)
{
typeMap.Seal(_typeMapRegistry, this);
}
}
public TypeMapConfigErrors(TypePair types, string[] profileNames)
{
Types = types;
ProfileNames = profileNames;
}
public Func <TSource, TDestination, ResolutionContext, TDestination> GetMapperFunc <TSource, TDestination>(TypePair types)
{
var key = new TypePair(typeof(TSource), typeof(TDestination));
var mapRequest = new MapRequest(key, types);
return((Func <TSource, TDestination, ResolutionContext, TDestination>)GetMapperFunc(mapRequest));
}
public MapRequest(TypePair requestedTypes, TypePair runtimeTypes, IMemberMap memberMap = null)
{
RequestedTypes = requestedTypes;
RuntimeTypes = runtimeTypes;
MemberMap = memberMap;
}
public TypeMap FindTypeMapFor(TypePair typePair) => _typeMapRegistry.GetTypeMap(typePair);
internal void IncrementTypeDepth(TypePair types)
{
TypeDepth[types]++;
}
public TypeMap ResolveTypeMap(TypePair typePair)
{
var typeMap = _typeMapPlanCache.GetOrAdd(typePair, _getTypeMap);
return(typeMap);
}
public bool TypeHasBeenIncluded(TypePair derivedTypes) => _includedDerivedTypes.Contains(derivedTypes);
private bool CoveredByObjectMap(TypePair typePair)
{
return(GetMappers().FirstOrDefault(m => m.IsMatch(typePair)) != null);
}
public TypeMap FindTypeMapFor(TypePair typePair) => _typeMapRegistry.GetOrDefault(typePair);
public MapRequest(TypePair requestedTypes, TypePair runtimeTypes)
{
RequestedTypes = requestedTypes;
RuntimeTypes = runtimeTypes;
}
public TypeMap ResolveTypeMap(TypePair typePair) => ResolveTypeMap(typePair, new DefaultTypeMapConfig(typePair));
internal int GetTypeDepth(TypePair types) => TypeDepth.TryGetValue(types, out int depth) ? depth : TypeDepth[types] = 1;
public bool TypeHasBeenIncluded(TypePair derivedTypes)
{
return(_includedDerivedTypes.Contains(derivedTypes));
}
public TypeMap FindTypeMapFor(object source, Type sourceType, Type destinationType)
{
var typeMapPair = new TypePair(sourceType, destinationType);
TypeMap typeMap;
if (!_typeMapCache.TryGetValue(typeMapPair, out typeMap))
{
// Cache miss
typeMap = FindTypeMap(source, sourceType, destinationType, DefaultProfileName);
//We don't want to inherit base mappings which may be ambiguous or too specific resulting in cast exceptions
if (source == null || source.GetType() == sourceType)
{
_typeMapCache[typeMapPair] = typeMap;
}
}
// Due to the inheritance we can have derrived mapping cached which is not valid for this source object
else if (source != null && typeMap != null && !typeMap.SourceType.IsAssignableFrom(source.GetType()))
{
typeMap = FindTypeMapFor(source, source.GetType(), destinationType);
}
if (typeMap != null && typeMap.DestinationTypeOverride != null)
{
return(FindTypeMapFor(source, sourceType, typeMap.DestinationTypeOverride));
}
// Check for runtime derived types
var shouldCheckDerivedType = (typeMap != null) && (typeMap.HasDerivedTypesToInclude()) && (source != null) && (source.GetType() != sourceType);
if (shouldCheckDerivedType)
{
var potentialSourceType = source.GetType();
//Try and get the most specific type map possible
var potentialTypes = _typeMaps
.Where(t =>
{
return(destinationType.IsAssignableFrom(t.DestinationType) &&
t.SourceType.IsAssignableFrom(source.GetType()) &&
(
destinationType.IsAssignableFrom(t.DestinationType) ||
t.GetDerivedTypeFor(potentialSourceType) != null
)
);
}
);
var potentialDestTypeMap =
potentialTypes
.OrderByDescending(t => GetInheritanceDepth(t.DestinationType))
.FirstOrDefault();
var ambiguousPotentialTypes = potentialTypes
.Where(t => t.DestinationType == potentialDestTypeMap.DestinationType)
.ToList();
if (ambiguousPotentialTypes.Count > 1)
{
potentialDestTypeMap = ambiguousPotentialTypes
.OrderByDescending(t => GetInheritanceDepth(t.SourceType))
.FirstOrDefault();
}
if (potentialDestTypeMap == typeMap)
{
return(typeMap);
}
var targetDestinationType = potentialDestTypeMap.DestinationType;
var potentialTypeMap = FindExplicitlyDefinedTypeMap(potentialSourceType, targetDestinationType);
if (potentialTypeMap == null)
{
var targetSourceType = targetDestinationType != destinationType ? potentialSourceType : typeMap.SourceType;
typeMap = FindTypeMap(source, targetSourceType, targetDestinationType, DefaultProfileName);
}
else
{
typeMap = potentialTypeMap;
}
}
return(typeMap);
}
public TypeMap ResolveTypeMap(Type sourceType, Type destinationType)
{
var typePair = new TypePair(sourceType, destinationType);
return(ResolveTypeMap(typePair));
}
public MapRequest(TypePair requestedTypes, TypePair runtimeTypes, PropertyMap propertyMap = null)
: this(requestedTypes, runtimeTypes, new MapperConfiguration.DefaultTypeMapConfig(requestedTypes), propertyMap)
{
}
