public ObjectMapper <TSource, TTarget> Create <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
var mappingExpressionFactory = _mappingExpressionFactories.First(mef => mef.IsFor(mappingData));
var mappingExpression = mappingExpressionFactory.Create(mappingData);
if (mappingExpression.NodeType == ExpressionType.Default)
{
return(null);
}
mappingExpression = MappingFactory
.UseLocalSourceValueVariableIfAppropriate(mappingExpression, mappingData.MapperData);
var mappingLambda = Expression.Lambda <MapperFunc <TSource, TTarget> >(
mappingExpression,
mappingData.MapperData.MappingDataObject);
var mapper = new ObjectMapper <TSource, TTarget>(mappingLambda, mappingData);
if (_creationCallbacksByKey == null)
{
return(mapper);
}
var creationCallbackKey = new MapperCreationCallbackKey(mappingData.MapperData);
if (_creationCallbacksByKey.TryGetValue(creationCallbackKey, out var creationCallback))
{
creationCallback.Invoke(mapper);
}
return(mapper);
}
public static ObjectMapperData For <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
int?dataSourceIndex;
ObjectMapperData parentMapperData;
IMembersSource membersSource;
if (mappingData.IsRoot)
{
parentMapperData = null;
membersSource = mappingData.MappingContext.MapperContext.RootMembersSource;
dataSourceIndex = null;
}
else if (UseExistingMapperData(mappingData, out var existingMapperData))
{
return(existingMapperData);
}
else
{
parentMapperData = mappingData.Parent.MapperData;
membersSource = mappingData.MapperKey.GetMembersSource(parentMapperData);
dataSourceIndex = membersSource.DataSourceIndex;
}
var sourceMember = membersSource.GetSourceMember <TSource, TTarget>().WithType(typeof(TSource));
var targetMember = membersSource.GetTargetMember <TSource, TTarget>().WithType(typeof(TTarget));
return(new ObjectMapperData(
mappingData,
sourceMember,
targetMember,
dataSourceIndex,
mappingData.DeclaredTypeMappingData?.MapperData,
parentMapperData,
mappingData.IsStandalone()));
}
private static bool UseExistingMapperData <TSource, TTarget>(
ObjectMappingData <TSource, TTarget> mappingData,
out ObjectMapperData existingMapperData)
{
if (!mappingData.IsPartOfRepeatedMapping)
{
existingMapperData = null;
return(false);
}
// RepeatedMappings are invoked through the entry point MapperData, which assigns
// itself as the ObjectMappingData's parent. If a repeated mapping then needs to
// do a runtime-typed child mapping, we're able to reuse the parent MapperData
// by finding it from the entry point:
var parentMapperData = mappingData.Parent.MapperData;
var membersSource = mappingData.MapperKey.GetMembersSource(parentMapperData);
if (!(membersSource is IChildMembersSource childMembersSource))
{
existingMapperData = null;
return(false);
}
var mapperTypes = new[] { typeof(TSource), typeof(TTarget) };
existingMapperData = GetMapperDataOrNull(
parentMapperData,
mapperTypes,
childMembersSource.TargetMemberRegistrationName);
return(existingMapperData != null);
}
public ObjectMapper <TSource, TTarget> Create <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
var mappingExpression = MappingDataSourceSetFactory.CreateFor(mappingData).BuildValue();
if (mappingExpression == Constants.EmptyExpression)
{
return(null);
}
mappingExpression = MappingFactory
.UseLocalSourceValueVariableIfAppropriate(mappingExpression, mappingData.MapperData);
var mapper = new ObjectMapper <TSource, TTarget>(mappingExpression, mappingData);
if (_creationCallbacksByKey == null)
{
return(mapper);
}
var creationCallbackKey = new MapperCreationCallbackKey(mappingData.MapperData);
if (_creationCallbacksByKey.TryGetValue(creationCallbackKey, out var creationCallback))
{
creationCallback.Invoke(mapper);
}
return(mapper);
}
public ObjectMapper <TSource, TTarget> GetOrCreateRoot <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
if (StaticMapperCache <TSource, TTarget> .TryGetMapperFor(mappingData, out var mapper))
{
return(mapper);
}
var rootMapperKey = mappingData.EnsureRootMapperKey();
mapper = (ObjectMapper <TSource, TTarget>)_rootMappersCache.GetOrAdd(
rootMapperKey,
key => key.MappingData.GetOrCreateMapper());
return(mapper);
}
public ObjectMapper <TSource, TTarget> Create <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
var mappingExpression = mappingData.MapperKey.MappingTypes.IsEnumerable
? _enumerableMappingExpressionFactory.Create(mappingData)
: _complexTypeMappingExpressionFactory.Create(mappingData);
mappingExpression = MappingFactory
.UseLocalSourceValueVariableIfAppropriate(mappingExpression, mappingData.MapperData);
var mappingLambda = Expression.Lambda <MapperFunc <TSource, TTarget> >(
mappingExpression,
mappingData.MapperData.MappingDataObject);
var mapper = new ObjectMapper <TSource, TTarget>(mappingLambda, mappingData.MapperData);
return(mapper);
}
public ObjectMapper <TSource, TTarget> GetOrCreateRoot <TSource, TTarget>(ObjectMappingData <TSource, TTarget> mappingData)
{
mappingData.MapperKey.MappingData = mappingData;
var mapper = RootMapperCache <TSource, TTarget> .Mappers.GetOrAdd(
mappingData.MapperKey,
key =>
{
var mapperToCache = (ObjectMapper <TSource, TTarget>)key.MappingData.Mapper;
key.MappingData = null;
_rootCacheEmptiers.Add(CacheEmptier <TSource, TTarget> .Instance);
return(mapperToCache);
});
return(mapper);
}
public TTarget Map(ObjectMappingData <TSource, TTarget> mappingData) => _mapperFunc.Invoke(mappingData);
public ChildMemberMappingData(ObjectMappingData <TSource, TTarget> parent, IMemberMapperData mapperData)
{
_parent = parent;
MapperData = mapperData;
}
public ChildMemberMappingData(ObjectMappingData <TSource, TTarget> parent)
{
_parent = parent;
_runtimeTypeGettersCache = parent.MapperContext.Cache.CreateScoped <IQualifiedMember, Func <TSource, Type> >();
}
