private static void MapPropertyValue(ResolutionContext context, IMappingEngineRunner mapper,
object mappedObject, PropertyMap propertyMap)
{
if (!propertyMap.CanResolveValue())
{
return;
}
var result = propertyMap.ResolveValue(context);
var newContext = context.CreateMemberContext(null, result.Value, null, result.Type, propertyMap);
if (!propertyMap.ShouldAssignValue(newContext))
{
return;
}
try
{
var propertyValueToAssign = mapper.Map(newContext);
if (propertyMap.CanBeSet)
{
propertyMap.DestinationProperty.SetValue(mappedObject, propertyValueToAssign);
}
}
catch (MapperMappingException)
{
throw;
}
catch (Exception ex)
{
throw new MapperMappingException(newContext, ex);
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var sourceDelegateType = context.SourceType.GetGenericArguments()[0];
var destDelegateType = context.DestinationType.GetGenericArguments()[0];
var expression = (LambdaExpression) context.SourceValue;
if (sourceDelegateType.GetGenericTypeDefinition() != destDelegateType.GetGenericTypeDefinition())
throw new AutoMapperMappingException("Source and destination expressions must be of the same type.");
var parameters = expression.Parameters.ToArray();
var body = expression.Body;
for (int i = 0; i < expression.Parameters.Count; i++)
{
var sourceParamType = sourceDelegateType.GetGenericArguments()[i];
var destParamType = destDelegateType.GetGenericArguments()[i];
if (sourceParamType == destParamType)
continue;
var typeMap = mapper.ConfigurationProvider.ResolveTypeMap(destParamType, sourceParamType);
if (typeMap == null)
throw new AutoMapperMappingException(
$"Could not find type map from destination type {destParamType} to source type {sourceParamType}. Use CreateMap to create a map from the source to destination types.");
var oldParam = expression.Parameters[i];
var newParam = Expression.Parameter(typeMap.SourceType, oldParam.Name);
parameters[i] = newParam;
var visitor = new MappingVisitor(typeMap, oldParam, newParam);
body = visitor.Visit(body);
}
return Expression.Lambda(body, parameters);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (IsDataReader(context))
{
var dataReader = (IDataReader)context.SourceValue;
var destinationElementType = TypeHelper.GetElementType(context.DestinationType);
var buildFrom = CreateBuilder(destinationElementType, dataReader);
var results = ObjectCreator.CreateList(destinationElementType);
while (dataReader.Read())
{
results.Add(buildFrom(dataReader));
}
return results;
}
if (IsDataRecord(context))
{
var dataRecord = context.SourceValue as IDataRecord;
var buildFrom = CreateBuilder(context.DestinationType, dataRecord);
var result = buildFrom(dataRecord);
MapPropertyValues(context, mapper, result);
return result;
}
return null;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var sourceElementType = TypeHelper.GetElementType(context.SourceValue.GetType());
var destinationElementType = TypeHelper.GetElementType(context.DestinationValue.GetType());
var equivilencyExpression = GetEquivilentExpression(context);
var sourceEnumerable = context.SourceValue as IEnumerable;
var destEnumerable = (IEnumerable)context.DestinationValue;
var destItems = destEnumerable.Cast<object>().ToList();
var sourceItems = sourceEnumerable.Cast<object>().ToList();
var compareSourceToDestination = sourceItems.ToDictionary(s => s, s => destItems.FirstOrDefault(d => equivilencyExpression.IsEquivlent(s, d)));
var actualDestType = destEnumerable.GetType();
var addMethod = actualDestType.GetMethod("Add");
foreach (var keypair in compareSourceToDestination)
{
if (keypair.Value == null)
addMethod.Invoke(destEnumerable, new[] { Mapper.Map(keypair.Key, sourceElementType, destinationElementType) });
else
Mapper.Map(keypair.Key, keypair.Value, sourceElementType, destinationElementType);
}
var removeMethod = actualDestType.GetMethod("Remove");
foreach (var removedItem in destItems.Except(compareSourceToDestination.Values))
removeMethod.Invoke(destEnumerable, new[] { removedItem });
return destEnumerable;
}
protected override object GetMappedObject(ResolutionContext context, IMappingEngineRunner mapper)
{
var result = context.DestinationValue;
context.SetResolvedDestinationValue(result);
return(result);
}
public object ResolveValue(ResolutionContext context, IMappingEngineRunner mappingEngine)
{
var ctorArgs = new List<object>();
foreach (var map in CtorParams)
{
var result = map.ResolveValue(context);
var sourceType = result.Type;
var destinationType = map.Parameter.ParameterType;
var typeMap = mappingEngine.ConfigurationProvider.ResolveTypeMap(result, destinationType);
Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;
var newContext = context.CreateTypeContext(typeMap, result.Value, null, targetSourceType,
destinationType);
if (typeMap == null && map.Parameter.IsOptional)
{
object value = map.Parameter.DefaultValue;
ctorArgs.Add(value);
}
else
{
var value = mappingEngine.Map(newContext);
ctorArgs.Add(value);
}
}
return _runtimeCtor.Value(ctorArgs.ToArray());
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (IsDataReader(context))
{
var useYieldReturn = ((IConfiguration)mapper.ConfigurationProvider).DataReaderMapperYieldReturnEnabled;
var destinationElementType = TypeHelper.GetElementType(context.DestinationType);
var results = MapDataReaderToEnumerable(context, mapper, destinationElementType, useYieldReturn);
if (useYieldReturn)
{
var adapterBuilder = GetDelegateToCreateEnumerableAdapter(destinationElementType);
return(adapterBuilder(results));
}
return(results);
}
if (IsDataRecord(context))
{
var dataRecord = context.SourceValue as IDataRecord;
var buildFrom = CreateBuilder(context.DestinationType, dataRecord);
var result = buildFrom(dataRecord);
MapPropertyValues(context, mapper, result);
return(result);
}
return(null);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var sourceDelegateType = context.SourceType.GetGenericArguments()[0];
var destDelegateType = context.DestinationType.GetGenericArguments()[0];
var expression = (LambdaExpression)context.SourceValue;
if (sourceDelegateType.GetGenericTypeDefinition() != destDelegateType.GetGenericTypeDefinition())
{
throw new AutoMapperMappingException("Source and destination expressions must be of the same type.");
}
var destArgType = destDelegateType.GetGenericArguments()[0];
if (destArgType.IsGenericType())
{
destArgType = destArgType.GetGenericArguments()[0];
}
var sourceArgType = sourceDelegateType.GetGenericArguments()[0];
if (sourceArgType.IsGenericType())
{
sourceArgType = sourceArgType.GetGenericArguments()[0];
}
var typeMap = Mapper.FindTypeMapFor(destArgType, sourceArgType);
var parentMasterVisitor = new MappingVisitor(destDelegateType.GetGenericArguments());
var typeMapVisitor = new MappingVisitor(typeMap, expression.Parameters[0], Expression.Parameter(destDelegateType.GetGenericArguments()[0], expression.Parameters[0].Name), parentMasterVisitor, destDelegateType.GetGenericArguments());
// Map expression body and variable seperately
var parameters = expression.Parameters.Select(typeMapVisitor.Visit).OfType <ParameterExpression>();
var body = typeMapVisitor.Visit(expression.Body);
return(Expression.Lambda(body, parameters));
}
public object ResolveValue(ResolutionContext context, IMappingEngineRunner mappingEngine)
{
var ctorArgs = new List <object>();
foreach (var map in CtorParams)
{
var result = map.ResolveValue(context);
var sourceType = result.Type;
var destinationType = map.Parameter.ParameterType;
var typeMap = mappingEngine.ConfigurationProvider.ResolveTypeMap(result, destinationType);
Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;
var newContext = context.CreateTypeContext(typeMap, result.Value, null, targetSourceType,
destinationType);
if (typeMap == null && map.Parameter.IsOptional)
{
object value = map.Parameter.DefaultValue;
ctorArgs.Add(value);
}
else
{
var value = mappingEngine.Map(newContext);
ctorArgs.Add(value);
}
}
return(_runtimeCtor.Value(ctorArgs.ToArray()));
}
static IEnumerable MapDataReaderToEnumerable(ResolutionContext context, IMappingEngineRunner mapper, Type destinationElementType, bool useYieldReturn)
{
var dataReader = (IDataReader)context.SourceValue;
var resolveUsingContext = context;
if (context.TypeMap == null)
{
var configurationProvider = mapper.ConfigurationProvider;
// v3.3.1
//TypeMap typeMap = configurationProvider.FindTypeMapFor(context.SourceValue, context.DestinationValue, context.SourceType, destinationElementType); // replace using new
// v4.1.1
var typeMap = configurationProvider.FindTypeMapFor(context.SourceType, destinationElementType);
resolveUsingContext = new ResolutionContext(typeMap, context.SourceValue, context.SourceType, destinationElementType, new MappingOperationOptions(), (IMappingEngine)mapper);
}
var buildFrom = CreateBuilder(destinationElementType, dataReader);
if (useYieldReturn)
{
return(LoadDataReaderViaYieldReturn(dataReader, mapper, buildFrom, resolveUsingContext));
}
return(LoadDataReaderViaList(dataReader, mapper, buildFrom, resolveUsingContext, destinationElementType));
}
private static void MapPropertyValues(ResolutionContext context, IMappingEngineRunner mapper, object result)
{
foreach (var propertyMap in context.TypeMap.GetPropertyMaps())
{
MapPropertyValue(context, mapper, result, propertyMap);
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var newSource = context.TypeMap.Substitution(context.SourceValue);
var substitutionContext = context.CreateValueContext(newSource, newSource.GetType());
return(mapper.Map(substitutionContext));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var destExpressArgType = context.DestinationType.GetSinglePredicateExpressionArgumentType();
var toSourceExpression = EquivilentExpressions.GetEquivilentExpression(context.SourceType, destExpressArgType) as IToSingleSourceEquivalentExpression;
return(toSourceExpression.ToSingleSourceExpression(context.SourceValue));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
bool toEnum = false;
Type enumSourceType = TypeHelper.GetEnumerationType(context.SourceType);
Type enumDestinationType = TypeHelper.GetEnumerationType(context.DestinationType);
if (EnumToStringMapping(context, ref toEnum))
{
if (context.SourceValue == null)
{
return(mapper.CreateObject(context));
}
if (toEnum)
{
var stringValue = context.SourceValue.ToString();
if (string.IsNullOrEmpty(stringValue))
{
return(mapper.CreateObject(context));
}
return(Enum.Parse(enumDestinationType, stringValue, true));
}
return(Enum.GetName(enumSourceType, context.SourceValue));
}
if (EnumToEnumMapping(context))
{
if (context.SourceValue == null)
{
return(mapper.CreateObject(context));
}
if (!Enum.IsDefined(enumSourceType, context.SourceValue))
{
return(Enum.ToObject(enumDestinationType, context.SourceValue));
}
#if !SILVERLIGHT
if (!Enum.GetNames(enumDestinationType).Contains(context.SourceValue.ToString()))
{
Type underlyingSourceType = Enum.GetUnderlyingType(enumSourceType);
var underlyingSourceValue = Convert.ChangeType(context.SourceValue, underlyingSourceType);
return(Enum.ToObject(context.DestinationType, underlyingSourceValue));
}
#endif
return(Enum.Parse(enumDestinationType, Enum.GetName(enumSourceType, context.SourceValue), true));
}
if (EnumToUnderlyingTypeMapping(context, ref toEnum))
{
if (toEnum)
{
return(Enum.Parse(enumDestinationType, context.SourceValue.ToString(), true));
}
return(Convert.ChangeType(context.SourceValue, context.DestinationType, null));
}
return(null);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
bool toEnum = false;
Type enumSourceType = TypeHelper.GetEnumerationType(context.SourceType);
Type enumDestinationType = TypeHelper.GetEnumerationType(context.DestinationType);
if (EnumToStringMapping(context, ref toEnum))
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
if (toEnum)
{
var stringValue = context.SourceValue.ToString();
if (string.IsNullOrEmpty(stringValue))
{
return mapper.CreateObject(context);
}
return Enum.Parse(enumDestinationType, stringValue, true);
}
return Enum.GetName(enumSourceType, context.SourceValue);
}
if (EnumToEnumMapping(context))
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
if (!Enum.IsDefined(enumSourceType, context.SourceValue))
{
return Enum.ToObject(enumDestinationType, context.SourceValue);
}
#if !SILVERLIGHT && !__ANDROID__
if (!Enum.GetNames(enumDestinationType).Contains(context.SourceValue.ToString()))
{
Type underlyingSourceType = Enum.GetUnderlyingType(enumSourceType);
var underlyingSourceValue = Convert.ChangeType(context.SourceValue, underlyingSourceType);
return Enum.ToObject(context.DestinationType, underlyingSourceValue);
}
#endif
return Enum.Parse(enumDestinationType, Enum.GetName(enumSourceType, context.SourceValue), true);
}
if (EnumToUnderlyingTypeMapping(context, ref toEnum))
{
if (toEnum)
{
return Enum.Parse(enumDestinationType, context.SourceValue.ToString(), true);
}
return Convert.ChangeType(context.SourceValue, context.DestinationType, null);
}
return null;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return(mapper.FormatValue(context.CreateValueContext(null)));
}
return(mapper.FormatValue(context));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return mapper.FormatValue(context.CreateValueContext(null));
}
return mapper.FormatValue(context);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var mapperToUse = _mappers.First(objectMapper => objectMapper.IsMatch(context, mapper));
object mappedObject = mapperToUse.Map(context, mapper);
context.TypeMap.AfterMap(context.SourceValue, mappedObject);
return mappedObject;
}
private void MapPropertyValue(ResolutionContext context, IMappingEngineRunner mapper, object mappedObject, PropertyMap propertyMap)
{
if (propertyMap.CanResolveValue())
{
ResolutionResult result;
try
{
result = propertyMap.ResolveValue(context);
}
catch (AutoMapperMappingException)
{
throw;
}
catch (Exception ex)
{
var errorContext = CreateErrorContext(context, propertyMap, null);
throw new AutoMapperMappingException(errorContext, ex);
}
if (result.ShouldIgnore)
{
return;
}
object destinationValue = propertyMap.DestinationProperty.GetValue(mappedObject);
var sourceType = result.Type;
var destinationType = propertyMap.DestinationProperty.MemberType;
var typeMap = mapper.ConfigurationProvider.FindTypeMapFor(result, destinationType);
Type targetSourceType = typeMap != null ? typeMap.SourceType : sourceType;
var newContext = context.CreateMemberContext(typeMap, result.Value, destinationValue, targetSourceType,
propertyMap);
if (!propertyMap.ShouldAssignValue(newContext))
{
return;
}
try
{
object propertyValueToAssign = mapper.Map(newContext);
AssignValue(propertyMap, mappedObject, propertyValueToAssign);
}
catch (AutoMapperMappingException)
{
throw;
}
catch (Exception ex)
{
throw new AutoMapperMappingException(newContext, ex);
}
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
Func<object> converter = GetConverter(context);
return converter != null ? converter() : null;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var typeMap = mapper.ConfigurationProvider.FindClosedGenericTypeMapFor(context);
var newContext = context.CreateTypeContext(typeMap, context.SourceValue, context.DestinationValue, context.SourceType,
context.DestinationType);
return mapper.Map(newContext);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
return context.SourceValue;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null && !mapper.ShouldMapSourceCollectionAsNull(context))
{
return(mapper.CreateObject(context));
}
return(context.SourceValue);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null && !mapper.ShouldMapSourceCollectionAsNull(context))
{
return mapper.CreateObject(context);
}
return context.SourceValue;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var source = context.SourceValue;
var sourceType = source.GetType();
var sourceTypeDetails = new TypeDetails(sourceType, _ => true, _ => true);
var membersDictionary = sourceTypeDetails.PublicReadAccessors.ToDictionary(p => p.Name, p => p.GetMemberValue(source));
var newContext = context.CreateTypeContext(null, membersDictionary, context.DestinationValue, membersDictionary.GetType(), context.DestinationType);
return mapper.Map(newContext);
}
static IEnumerable LoadDataReaderViaYieldReturn(IDataReader dataReader, IMappingEngineRunner mapper, Build buildFrom, ResolutionContext resolveUsingContext)
{
while (dataReader.Read())
{
var result = buildFrom(dataReader);
MapPropertyValues(resolveUsingContext, mapper, result);
yield return(result);
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var typeMap = mapper.ConfigurationProvider.FindClosedGenericTypeMapFor(context);
var newContext = context.CreateTypeContext(typeMap, context.SourceValue, context.DestinationValue, context.SourceType,
context.DestinationType);
return(mapper.Map(newContext));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var newSource = context.TypeMap.Substitution(context.SourceValue);
var typeMap = mapper.ConfigurationProvider.ResolveTypeMap(newSource.GetType(), context.DestinationType);
var substitutionContext = context.CreateTypeContext(typeMap, newSource, context.DestinationValue,
newSource.GetType(), context.DestinationType);
return mapper.Map(substitutionContext);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var newSource = context.TypeMap.Substitution(context.SourceValue);
var typeMap = mapper.ConfigurationProvider.ResolveTypeMap(newSource.GetType(), context.DestinationType);
var substitutionContext = context.CreateTypeContext(typeMap, newSource, context.DestinationValue,
newSource.GetType(), context.DestinationType);
return(mapper.Map(substitutionContext));
}
protected override object GetMappedObject(ResolutionContext context, IMappingEngineRunner mapper)
{
var result = mapper.CreateObject(context);
if (result == null)
{
throw new InvalidOperationException("Cannot create destination object. " + context);
}
return(result);
}
private IConfigurationProvider GetConfigurationProvider()
{
IMappingEngineRunner runner = engine as IMappingEngineRunner;
if (runner == null)
{
throw new ArgumentException(Resources.Error.AutoMapperInvalidEngine);
}
return(runner.ConfigurationProvider);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
context.TypeMap.Seal();
var mapperToUse = _mappers.First(objectMapper => objectMapper.IsMatch(context, mapper));
object mappedObject = mapperToUse.Map(context, mapper);
context.TypeMap.AfterMap(context.SourceValue, mappedObject);
return(mappedObject);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return(mapper.CreateObject(context));
}
Func <object> converter = GetConverter(context);
return(converter != null?converter() : null);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
TypeConverter typeConverter = GetTypeConverter(context);
return typeConverter.ConvertTo(context.SourceValue, context.DestinationType);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var source = context.SourceValue;
var sourceType = source.GetType();
var sourceTypeDetails = new TypeDetails(sourceType, _ => true, _ => true);
var membersDictionary = sourceTypeDetails.PublicReadAccessors.ToDictionary(p => p.Name, p => p.GetMemberValue(source));
var newContext = context.CreateTypeContext(null, membersDictionary, context.DestinationValue, membersDictionary.GetType(), context.DestinationType);
return(mapper.Map(newContext));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.SourceValue == null)
{
return(mapper.CreateObject(context));
}
TypeConverter typeConverter = GetTypeConverter(context);
return(typeConverter.ConvertTo(context.SourceValue, context.DestinationType));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var enumDestType = TypeHelper.GetEnumerationType(context.DestinationType);
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
return Enum.Parse(enumDestType, context.SourceValue.ToString(), true);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var contextTypePair = new TypePair(context.SourceType, context.DestinationType);
Func<TypePair, IObjectMapper> missFunc = tp => context.Engine.ConfigurationProvider.GetMappers().FirstOrDefault(m => m.IsMatch(context));
var typeMap = mapper.ConfigurationProvider.CreateTypeMap(context.SourceType, context.DestinationType, _profileName);
context = context.CreateTypeContext(typeMap, context.SourceValue, context.DestinationValue, context.SourceType, context.DestinationType);
var map = (context.Engine as MappingEngine)._objectMapperCache.GetOrAdd(contextTypePair, missFunc);
return map.Map(context, mapper);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context == null) throw new ArgumentNullException("context");
if (mapper == null) throw new ArgumentNullException("mapper");
if (context.SourceValue == null)
{
return mapper.FormatValue(context.CreateValueContext(null));
}
return mapper.FormatValue(context);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
context.TypeMap.Seal();
var mapperToUse = _mappers.First(objectMapper => objectMapper.IsMatch(context, mapper));
// check whether the context passes conditions before attempting to map the value (depth check)
var mappedObject = !context.TypeMap.ShouldAssignValue(context) ? null : mapperToUse.Map(context, mapper);
return mappedObject;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var enumDestType = TypeHelper.GetEnumerationType(context.DestinationType);
if (context.SourceValue == null)
{
return(mapper.CreateObject(context));
}
return(Enum.Parse(enumDestType, context.SourceValue.ToString(), true));
}
protected virtual object CreateDestinationObject(ResolutionContext context, Type destinationElementType,
int count, IMappingEngineRunner mapper)
{
var destinationType = context.DestinationType;
if (!destinationType.IsInterface() && !destinationType.IsArray)
{
return(mapper.CreateObject(context));
}
return(CreateDestinationObjectBase(destinationElementType, count));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
context.TypeMap.Seal();
var mapperToUse = _mappers.First(objectMapper => objectMapper.IsMatch(context, mapper));
// check whether the context passes conditions before attempting to map the value (depth check)
object mappedObject = !context.TypeMap.ShouldAssignValue(context) ? null : mapperToUse.Map(context, mapper);
return(mappedObject);
}
private static void MapPropertyValues(ResolutionContext context, IMappingEngineRunner mapper, object result)
{
if (context.TypeMap == null)
{
throw new MapperMappingException(context, "Missing type map configuration or unsupported mapping.");
}
foreach (var propertyMap in context.TypeMap.GetPropertyMaps())
{
MapPropertyValue(context, mapper, result, propertyMap);
}
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var contextTypePair = new TypePair(context.SourceType, context.DestinationType);
Func <TypePair, IObjectMapper> missFunc = tp => context.Engine.ConfigurationProvider.GetMappers().FirstOrDefault(m => m.IsMatch(context));
var typeMap = mapper.ConfigurationProvider.CreateTypeMap(context.SourceType, context.DestinationType, _profileName);
context = context.CreateTypeContext(typeMap, context.SourceValue, context.DestinationValue, context.SourceType, context.DestinationType);
var map = context.Engine.GetOrAddMapper(contextTypePair, missFunc);
return(map.Map(context, mapper));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context == null) throw new ArgumentNullException("context");
if (mapper == null) throw new ArgumentNullException("mapper");
if (context.SourceValue == null && !mapper.ShouldMapSourceValueAsNull(context))
{
return mapper.CreateObject(context);
}
return context.SourceValue;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (!IsMatch(context) || context.SourceValue == null)
return null;
var nvc = new NameValueCollection();
var source = context.SourceValue as NameValueCollection;
foreach (var s in source.AllKeys)
nvc.Add(s, source[s]);
return nvc;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
Type genericType = typeof(EnumerableMapper <>);
var elementType = TypeHelper.GetElementType(context.DestinationType);
var enumerableMapper = genericType.MakeGenericType(elementType);
var objectMapper = (IObjectMapper)Activator.CreateInstance(enumerableMapper);
return(objectMapper.Map(context, mapper));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.IsSourceValueNull && mapper.ShouldMapSourceCollectionAsNull(context))
{
return(null);
}
var sourceEnumerableValue = (IEnumerable)context.SourceValue ?? new object[0];
IEnumerable <object> keyValuePairs = sourceEnumerableValue.Cast <object>();
Type genericSourceDictType = context.SourceType.GetDictionaryType();
Type sourceKeyType = genericSourceDictType.GetGenericArguments()[0];
Type sourceValueType = genericSourceDictType.GetGenericArguments()[1];
Type sourceKvpType = KvpType.MakeGenericType(sourceKeyType, sourceValueType);
Type genericDestDictType = context.DestinationType.GetDictionaryType();
Type destKeyType = genericDestDictType.GetGenericArguments()[0];
Type destValueType = genericDestDictType.GetGenericArguments()[1];
var dictionaryEntries = keyValuePairs.OfType <DictionaryEntry>();
if (dictionaryEntries.Any())
{
keyValuePairs = dictionaryEntries.Select(e => Activator.CreateInstance(sourceKvpType, e.Key, e.Value));
}
object destDictionary = ObjectCreator.CreateDictionary(context.DestinationType, destKeyType, destValueType);
int count = 0;
foreach (object keyValuePair in keyValuePairs)
{
object sourceKey = sourceKvpType.GetProperty("Key").GetValue(keyValuePair, new object[0]);
object sourceValue = sourceKvpType.GetProperty("Value").GetValue(keyValuePair, new object[0]);
TypeMap keyTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceKey, null, sourceKeyType,
destKeyType);
TypeMap valueTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceValue, null, sourceValueType,
destValueType);
ResolutionContext keyContext = context.CreateElementContext(keyTypeMap, sourceKey, sourceKeyType,
destKeyType, count);
ResolutionContext valueContext = context.CreateElementContext(valueTypeMap, sourceValue, sourceValueType,
destValueType, count);
object destKey = mapper.Map(keyContext);
object destValue = mapper.Map(valueContext);
genericDestDictType.GetMethod("Add").Invoke(destDictionary, new[] { destKey, destValue });
count++;
}
return(destDictionary);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if(context == null) throw new ArgumentNullException("context");
context.TypeMap.Seal();
var mapperToUse = _mappers.First(objectMapper => objectMapper.IsMatch(context, mapper));
object mappedObject = mapperToUse.Map(context, mapper);
context.TypeMap.AfterMap(context.SourceValue, mappedObject);
return mappedObject;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
Type enumDestType = TypeHelper.GetEnumerationType(context.DestinationType);
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
Type enumSourceType = TypeHelper.GetEnumerationType(context.SourceType);
return Enum.Parse(enumDestType, Enum.GetName(enumSourceType, context.SourceValue));
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context == null) throw new ArgumentNullException("context");
if (mapper == null) throw new ArgumentNullException("mapper");
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
TypeConverter typeConverter = GetTypeConverter(context);
return typeConverter.ConvertTo(context.SourceValue, context.DestinationType);
}
static IEnumerable LoadDataReaderViaList(IDataReader dataReader, IMappingEngineRunner mapper, Build buildFrom, ResolutionContext resolveUsingContext, Type elementType)
{
var list = ObjectCreator.CreateList(elementType);
while (dataReader.Read())
{
var result = buildFrom(dataReader);
MapPropertyValues(resolveUsingContext, mapper, result);
list.Add(result);
}
return(list);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var dictionary = (StringDictionary)context.SourceValue;
object destination = mapper.CreateObject(context);
var destTypeDetails = new TypeDetails(context.DestinationType, _ => true, _ => true);
var members = from name in dictionary.Keys join member in destTypeDetails.PublicWriteAccessors on name equals member.Name select member;
foreach(var member in members)
{
object value = ReflectionHelper.Map(member, dictionary[member.Name]);
member.SetMemberValue(destination, value);
}
return destination;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context == null) throw new ArgumentNullException("context");
if (mapper == null) throw new ArgumentNullException("mapper");
bool toEnum = false;
Type enumSourceType = TypeHelper.GetEnumerationType(context.SourceType);
Type enumDestinationType = TypeHelper.GetEnumerationType(context.DestinationType);
if (EnumToStringMapping(context, ref toEnum))
{
if (toEnum)
{
return Enum.Parse(enumDestinationType, context.SourceValue.ToString(), true);
}
return Enum.GetName(enumSourceType, context.SourceValue);
}
if (EnumToEnumMapping(context))
{
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
if (!Enum.IsDefined(enumSourceType, context.SourceValue))
{
return Enum.ToObject(enumDestinationType, context.SourceValue);
}
#if !SILVERLIGHT
if (!Enum.GetNames(enumDestinationType).Contains(context.SourceValue.ToString()))
{
Type underlyingSourceType = Enum.GetUnderlyingType(enumSourceType);
var underlyingSourceValue = Convert.ChangeType(context.SourceValue, underlyingSourceType);
return Enum.ToObject(context.DestinationType, underlyingSourceValue);
}
#endif
return Enum.Parse(enumDestinationType, Enum.GetName(enumSourceType, context.SourceValue), true);
}
if (EnumToUnderlyingTypeMapping(context, ref toEnum))
{
if (toEnum)
{
return Enum.Parse(enumDestinationType, context.SourceValue.ToString(), true);
}
return Convert.ChangeType(context.SourceValue, context.DestinationType, null);
}
return null;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
Hashtable sourceHashtable = (Hashtable)context.SourceValue ?? new Hashtable();
object destinationObject = ObjectCreator.CreateObject(context.DestinationType);
foreach (DictionaryEntry entry in sourceHashtable)
{
if (entry.Value == null)
continue;
object sourceValue = entry.Value;
Type sourceValueType = sourceValue.GetType();
var propertyInfo = context.DestinationType.GetProperty(entry.Key.ToString());
if (propertyInfo == null)
continue;
var setter = propertyInfo.GetSetMethod(true);
if (setter == null)
continue;
Type destinationMemberType = propertyInfo.PropertyType;
// try to set object as is
try
{
// if needs to be casted:
if (destinationMemberType != sourceValueType)
sourceValue = Convert.ChangeType(entry.Value, destinationMemberType);
setter.Invoke(destinationObject, new[] { sourceValue });
continue;
}
catch (Exception e)
{
}
// swallowed, try to leverage type converters.
var converter = TypeDescriptor.GetConverter(destinationMemberType);
if (converter == null || !converter.CanConvertFrom(sourceValueType))
continue;
var destValue = converter.ConvertFrom(entry.Value);
setter.Invoke(destinationObject, new[] { destValue });
}
MapPropertyValues(context, mapper, destinationObject);
return destinationObject;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context == null) throw new ArgumentNullException("context");
if (mapper == null) throw new ArgumentNullException("mapper");
Type enumDestType = TypeHelper.GetEnumerationType(context.DestinationType);
if (context.SourceValue == null)
{
return mapper.CreateObject(context);
}
return Enum.Parse(enumDestType, context.SourceValue.ToString(), true);
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
if (context.IsSourceValueNull && mapper.ShouldMapSourceCollectionAsNull(context))
return null;
var sourceEnumerableValue = (IEnumerable) context.SourceValue ?? new object[0];
IEnumerable<object> keyValuePairs = sourceEnumerableValue.Cast<object>();
Type genericSourceDictType = context.SourceType.GetDictionaryType();
Type sourceKeyType = genericSourceDictType.GetGenericArguments()[0];
Type sourceValueType = genericSourceDictType.GetGenericArguments()[1];
Type sourceKvpType = KvpType.MakeGenericType(sourceKeyType, sourceValueType);
Type genericDestDictType = context.DestinationType.GetDictionaryType();
Type destKeyType = genericDestDictType.GetGenericArguments()[0];
Type destValueType = genericDestDictType.GetGenericArguments()[1];
var dictionaryEntries = keyValuePairs.OfType<DictionaryEntry>();
if (dictionaryEntries.Any())
keyValuePairs = dictionaryEntries.Select(e => Activator.CreateInstance(sourceKvpType, e.Key, e.Value));
object destDictionary = ObjectCreator.CreateDictionary(context.DestinationType, destKeyType, destValueType);
int count = 0;
foreach (object keyValuePair in keyValuePairs)
{
object sourceKey = sourceKvpType.GetProperty("Key").GetValue(keyValuePair, new object[0]);
object sourceValue = sourceKvpType.GetProperty("Value").GetValue(keyValuePair, new object[0]);
TypeMap keyTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceKey, null, sourceKeyType,
destKeyType);
TypeMap valueTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceValue, null, sourceValueType,
destValueType);
ResolutionContext keyContext = context.CreateElementContext(keyTypeMap, sourceKey, sourceKeyType,
destKeyType, count);
ResolutionContext valueContext = context.CreateElementContext(valueTypeMap, sourceValue, sourceValueType,
destValueType, count);
object destKey = mapper.Map(keyContext);
object destValue = mapper.Map(valueContext);
genericDestDictType.GetMethod("Add").Invoke(destDictionary, new[] {destKey, destValue});
count++;
}
return destDictionary;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var collection = context.SourceValue as SPListItemCollection;
//1. Need to create single item type
var elementType = context.DestinationType.GetGenericArguments()[0];
//2. Need to create result with generic type
var resultCollection = Activator.CreateInstance(context.DestinationType) as IList;
foreach (var item in collection)
{
var mappedItem = Mapper.Map(item, typeof(SPListItem), elementType);
resultCollection.Add(mappedItem);
}
return resultCollection;
}
public object Map(ResolutionContext context, IMappingEngineRunner mapper)
{
var mappedObject = GetMappedObject(context, mapper);
if (context.SourceValue != null && !context.Options.DisableCache)
context.InstanceCache[context] = mappedObject;
context.TypeMap.BeforeMap(context.SourceValue, mappedObject);
foreach (PropertyMap propertyMap in context.TypeMap.GetPropertyMaps())
{
MapPropertyValue(context.CreatePropertyMapContext(propertyMap), mapper, mappedObject, propertyMap);
}
mappedObject = ReassignValue(context, mappedObject);
context.TypeMap.AfterMap(context.SourceValue, mappedObject);
return mappedObject;
}
