private static IEnumerable <DictionaryTargetMember> EnumerateTargetMembers(
IEnumerable <Member> sourceMembers,
DictionaryTargetMember targetDictionaryMember,
ObjectMapperData mapperData,
Func <Member, string> targetMemberNameFactory)
{
foreach (var sourceMember in sourceMembers)
{
var targetEntryMemberName = targetMemberNameFactory.Invoke(sourceMember);
var targetEntryMember = targetDictionaryMember.Append(sourceMember.DeclaringType, targetEntryMemberName);
if (targetDictionaryMember.HasObjectEntries)
{
targetEntryMember = (DictionaryTargetMember)targetEntryMember.WithType(sourceMember.Type);
}
var entryMapperData = new ChildMemberMapperData(targetEntryMember, mapperData);
var configuredKey = GetCustomKeyOrNull(entryMapperData);
if (configuredKey != null)
{
targetEntryMember.SetCustomKey(configuredKey);
}
if (!sourceMember.IsSimple && !targetDictionaryMember.HasComplexEntries)
{
targetEntryMember = targetEntryMember.WithTypeOf(sourceMember);
}
yield return(targetEntryMember);
}
}
public MemberPopulationContext With(QualifiedMember targetMember)
{
MemberMapperData = new ChildMemberMapperData(targetMember, MapperData);
_memberIgnore = null;
_memberIgnoreChecked = false;
return(this);
}
private static IMemberPopulator Create(QualifiedMember targetMember, IObjectMappingData mappingData)
{
var childMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData);
if (childMapperData.TargetMemberIsUnmappable(out var reason))
{
return(MemberPopulator.Unmappable(childMapperData, reason));
}
if (TargetMemberIsUnconditionallyIgnored(
childMapperData,
out var configuredIgnore,
out var populateCondition))
{
return(MemberPopulator.IgnoredMember(childMapperData, configuredIgnore));
}
var childMappingData = mappingData.GetChildMappingData(childMapperData);
var dataSources = DataSourceFinder.FindFor(childMappingData);
if (dataSources.None)
{
return(MemberPopulator.NoDataSource(childMapperData));
}
return(MemberPopulator.WithRegistration(childMappingData, dataSources, populateCondition));
}
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember)
{
if (!valueLambdaInfo.TryGetSourceMember(out var sourceMemberLambda))
{
return;
}
var mappingData = _configInfo.ToMappingData <TSource, TTarget>();
var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData);
var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData);
var bestSourceMemberMatch = SourceMemberMatcher.GetMatchFor(targetMemberMappingData);
if (!bestSourceMemberMatch.IsUseable)
{
return;
}
var configuredSourceMember = sourceMemberLambda.ToSourceMember(MapperContext);
if (!bestSourceMemberMatch.SourceMember.Matches(configuredSourceMember))
{
return;
}
throw new MappingConfigurationException(string.Format(
CultureInfo.InvariantCulture,
"Source member {0} will automatically be mapped to target {1} {2}, " +
"and does not need to be configured",
GetSourceMemberDescription(configuredSourceMember),
GetTargetMemberType(targetMember),
targetMember.GetFriendlyTargetPath(_configInfo)));
}
private static IMemberPopulation Create(Member targetMember, IObjectMappingData mappingData)
{
var qualifiedMember = mappingData.MapperData.TargetMember.Append(targetMember);
var childMapperData = new ChildMemberMapperData(qualifiedMember, mappingData.MapperData);
Expression populateCondition;
if (TargetMemberIsUnconditionallyIgnored(childMapperData, out populateCondition))
{
return(MemberPopulation.IgnoredMember(childMapperData));
}
var childMappingData = mappingData.GetChildMappingData(childMapperData);
var dataSources = childMapperData
.MapperContext
.DataSources
.FindFor(childMappingData);
if (dataSources.None)
{
return(MemberPopulation.NoDataSource(childMapperData));
}
return(new MemberPopulation(childMapperData, dataSources, populateCondition));
}
public IEnumerable <IDataSource> FindFor(DataSourceFindContext context)
{
if (context.MapperData.TargetMember.IsCustom)
{
yield break;
}
var matchingSourceMemberDataSource = GetSourceMemberDataSourceOrNull(context);
var configuredDataSources = context.ConfiguredDataSources;
var targetMember = context.MapperData.TargetMember;
if ((matchingSourceMemberDataSource == null) ||
configuredDataSources.Any(cds => cds.IsSameAs(matchingSourceMemberDataSource)))
{
if (context.DataSourceIndex == 0)
{
if (UseFallbackComplexTypeMappingDataSource(targetMember))
{
yield return(new ComplexTypeMappingDataSource(context.DataSourceIndex, context.ChildMappingData));
}
}
else if (configuredDataSources.Any() && configuredDataSources.Last().IsConditional)
{
yield return(context.GetFallbackDataSource());
}
yield break;
}
if (matchingSourceMemberDataSource.SourceMember.IsSimple &&
context.MapperData.MapperContext.UserConfigurations.HasConfiguredRootDataSources)
{
var updatedMapperData = new ChildMemberMapperData(
matchingSourceMemberDataSource.SourceMember,
targetMember,
context.MapperData.Parent);
var configuredRootDataSources = context
.MapperData
.MapperContext
.UserConfigurations
.GetDataSources(updatedMapperData);
foreach (var configuredRootDataSource in configuredRootDataSources)
{
yield return(configuredRootDataSource);
}
}
yield return(matchingSourceMemberDataSource);
if (!targetMember.IsReadOnly &&
matchingSourceMemberDataSource.IsConditional &&
(matchingSourceMemberDataSource.IsValid || configuredDataSources.Any()))
{
yield return(context.GetFallbackDataSource());
}
}
public static IEnumerable <IDataSource> Create(DataSourceFindContext context)
{
if (context.TargetMember.IsCustom)
{
yield break;
}
if (context.DoNotUseSourceMemberDataSource())
{
if (context.DataSourceIndex == 0)
{
if (context.UseFallbackComplexTypeDataSource())
{
yield return(ComplexTypeDataSource.Create(context.DataSourceIndex, context.MemberMappingData));
}
}
else if (context.UseFallbackForConditionalConfiguredDataSource())
{
yield return(context.GetFallbackDataSource());
}
if (context.UseConfiguredDataSourcesOnly())
{
yield break;
}
}
if (context.ReturnSimpleTypeToTargetDataSources())
{
var updatedMapperData = new ChildMemberMapperData(
context.MatchingSourceMemberDataSource.SourceMember,
context.TargetMember,
context.MemberMapperData.Parent);
var configuredRootDataSources = context
.MapperContext
.UserConfigurations
.GetDataSourcesForToTarget(updatedMapperData);
foreach (var configuredRootDataSource in configuredRootDataSources)
{
yield return(configuredRootDataSource);
}
}
yield return(context.MatchingSourceMemberDataSource);
if (context.UseFallbackDataSource())
{
yield return(context.GetFallbackDataSource());
}
}
private IQualifiedMember GetMatchingSourceMember <TSource, TTarget>(
TSource source,
TTarget target,
Expression <Func <TTarget, object> > childMemberExpression)
{
var targetMember = TargetMemberFor(childMemberExpression);
var mappingContext = new SimpleMappingContext(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext);
var rootMappingData = ObjectMappingDataFactory.ForRoot(source, target, mappingContext);
var rootMapperData = rootMappingData.MapperData;
var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData);
var childMappingContext = rootMappingData.GetChildMappingData(childMapperData);
return(SourceMemberMatcher.GetMatchFor(childMappingContext, out _));
}
private static IDataSourceSet[] GetArgumentDataSources(TInvokable invokable, ConstructionKey key)
{
return(invokable
.GetParameters()
.ProjectToArray(key.MappingData, (mappingData, p) =>
{
var parameterMapperData = new ChildMemberMapperData(
mappingData.MapperData.TargetMember.Append(Member.ConstructorParameter(p)),
mappingData.MapperData);
var memberMappingData = mappingData.GetChildMappingData(parameterMapperData);
var dataSources = DataSourceSetFactory.CreateFor(new DataSourceFindContext(memberMappingData));
return dataSources;
}));
}
private static Tuple <QualifiedMember, DataSourceSet>[] GetArgumentDataSources(TInvokable invokable, ConstructionKey key)
{
return(invokable
.GetParameters()
.ProjectToArray(p =>
{
var parameterMapperData = new ChildMemberMapperData(
key.MappingData.MapperData.TargetMember.Append(Member.ConstructorParameter(p)),
key.MappingData.MapperData);
var memberMappingData = key.MappingData.GetChildMappingData(parameterMapperData);
var dataSources = DataSourceFinder.FindFor(memberMappingData);
return Tuple.Create(memberMappingData.MapperData.TargetMember, dataSources);
}));
}
private Expression GetPopulation(
Expression elementMapping,
QualifiedMember dictionaryEntryMember,
IObjectMappingData mappingData)
{
var elementMapperData = new ChildMemberMapperData(dictionaryEntryMember, MapperData);
var sourceMember = mappingData.MapperData.SourceMember;
var mappingDataSource = new AdHocDataSource(sourceMember, elementMapping);
var dataSourceSetInfo = new SimpleDataSourceSetInfo(mappingData.MappingContext, elementMapperData);
var mappingDataSources = DataSourceSet.For(mappingDataSource, dataSourceSetInfo);
var populator = new MemberPopulator(mappingDataSources, elementMapperData);
var populationExpression = populator.GetPopulation();
return(populationExpression);
}
private Expression GetPopulation(
Expression elementMapping,
QualifiedMember dictionaryEntryMember,
IObjectMappingData mappingData)
{
var elementMapperData = new ChildMemberMapperData(dictionaryEntryMember, MapperData);
var sourceMember = mappingData.MapperData.SourceMember;
var mappingDataSource = new AdHocDataSource(sourceMember, elementMapping);
var mappingDataSources = DataSourceSet.For(mappingDataSource, elementMapperData);
var populationExpression = MemberPopulator
.WithoutRegistration(mappingDataSources)
.GetPopulation();
return(populationExpression);
}
private IList <ConfiguredDataSourceFactoryBase> GetRelevantConfiguredDataSourceFactories()
{
var relevantDataSourceFactories = GetRelevantConfiguredDataSourceFactories(MemberMapperData);
if (!MemberMapperData.Parent.Context.IsForToTargetMapping)
{
return(relevantDataSourceFactories);
}
var originalChildMapperData = new ChildMemberMapperData(
TargetMember,
MemberMapperData.Parent.OriginalMapperData);
relevantDataSourceFactories = relevantDataSourceFactories.Append(
GetRelevantConfiguredDataSourceFactories(originalChildMapperData));
return(relevantDataSourceFactories);
}
public DataSourceFindContext(IChildMemberMappingData childMappingData)
{
ChildMappingData = childMappingData;
ConfiguredDataSources = GetConfiguredDataSources(MapperData);
if (!MapperData.Parent.Context.IsForToTargetMapping)
{
return;
}
var originalChildMapperData = new ChildMemberMapperData(
MapperData.TargetMember,
MapperData.Parent.OriginalMapperData);
ConfiguredDataSources = ConfiguredDataSources.Append(
GetConfiguredDataSources(originalChildMapperData));
}
public void ShouldNotMatchSameNameIncompatibleTypeProperties()
{
var source = new TwoValues {
Value = new int[5], value = string.Empty
};
var target = new PublicProperty <byte>();
var targetMember = TargetMemberFor <PublicProperty <byte> >(x => x.Value);
var mappingContext = new MappingExecutor <TwoValues>(DefaultMapperContext.RuleSets.CreateNew, DefaultMapperContext);
var rootMappingData = mappingContext.CreateRootMappingData(source, target);
var rootMapperData = rootMappingData.MapperData;
var childMapperData = new ChildMemberMapperData(targetMember, rootMapperData);
var childMappingContext = rootMappingData.GetChildMappingData(childMapperData);
var matchingSourceMember = SourceMemberMatcher.GetMatchFor(childMappingContext);
matchingSourceMember.ShouldNotBeNull();
matchingSourceMember.Name.ShouldBe("value");
}
protected ConstructionDataInfo(
TInvokable invokable,
ConstructionKey key,
int priority)
{
var parameters = invokable.GetParameters();
Priority = priority;
ParameterCount = parameters.Length;
_argumentTargetMembers = new QualifiedMember[ParameterCount];
ArgumentDataSources = new IDataSourceSet[ParameterCount];
CanBeInvoked = IsUnconditional = true;
var mappingData = key.MappingData;
var mapperData = mappingData.MapperData;
for (var i = 0; i < ParameterCount; ++i)
{
var argumentMember = Member.ConstructorParameter(parameters[i]);
var targetMember = _argumentTargetMembers[i] =
mapperData.TargetMember.Append(argumentMember);
var argumentMapperData = new ChildMemberMapperData(targetMember, mapperData);
var argumentMappingData = mappingData.GetChildMappingData(argumentMapperData);
var dataSources = ArgumentDataSources[i] = MemberDataSourceSetFactory
.CreateFor(new DataSourceFindContext(argumentMappingData));
if (CanBeInvoked && !dataSources.HasValue)
{
CanBeInvoked = false;
}
if (IsUnconditional && dataSources.IsConditional && argumentMember.IsComplex)
{
IsUnconditional = false;
}
}
}
private void ThrowIfRedundantSourceMember(ConfiguredLambdaInfo valueLambdaInfo, QualifiedMember targetMember)
{
if (!valueLambdaInfo.IsSourceMember(out var sourceMemberLambda))
{
return;
}
var mappingData = _configInfo.ToMappingData <TSource, TTarget>();
var targetMemberMapperData = new ChildMemberMapperData(targetMember, mappingData.MapperData);
var targetMemberMappingData = mappingData.GetChildMappingData(targetMemberMapperData);
var bestMatchingSourceMember = SourceMemberMatcher.GetMatchFor(targetMemberMappingData, out _);
if (bestMatchingSourceMember == null)
{
return;
}
var sourceMember = sourceMemberLambda.ToSourceMember(MapperContext);
if (!bestMatchingSourceMember.Matches(sourceMember))
{
return;
}
var targetMemberType = (targetMember.LeafMember.MemberType == MemberType.ConstructorParameter)
? "constructor parameter"
: "member";
throw new MappingConfigurationException(string.Format(
CultureInfo.InvariantCulture,
"Source member {0} will automatically be mapped to target {1} {2}, " +
"and does not need to be configured",
GetSourceMemberDescription(sourceMember),
targetMemberType,
targetMember.GetFriendlyTargetPath(_configInfo)));
}
private static bool TryGetMetaMember(
IList <string> memberNameParts,
DataSourceFindContext context,
out MetaMemberPartBase metaMember)
{
var currentMappingData = default(IObjectMappingData);
var currentSourceMember = default(IQualifiedMember);
var currentTargetMember = default(QualifiedMember);
var currentMemberPart = metaMember = default(MetaMemberPartBase);
Func <IQualifiedMember, QualifiedMember, IObjectMappingData, DataSourceFindContext, IObjectMappingData> currentMappingDataFactory =
(sm, tm, md, c) => c.ChildMappingData.Parent;
for (var i = memberNameParts.Count - 1; i >= 0; --i)
{
var memberNamePart = memberNameParts[i];
switch (memberNamePart)
{
case HasMetaMemberPart.Name:
if (HasMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
case FirstMetaMemberPart.Name:
currentMemberPart = new FirstMetaMemberPart(context.MapperData);
break;
case LastMetaMemberPart.Name:
currentMemberPart = new LastMetaMemberPart(context.MapperData);
break;
case CountMetaMemberPart.Name:
if (CountMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
case NumberOfMetaMemberPart.Name:
if (NumberOfMetaMemberPart.TryCreateFor(context.MapperData, ref currentMemberPart))
{
break;
}
return(false);
default:
currentMappingData = currentMappingDataFactory.Invoke(
currentSourceMember,
currentTargetMember,
currentMappingData,
context);
var currentMapperData = currentMappingData.MapperData;
var matchingTargetMember = GlobalContext.Instance
.MemberCache
.GetTargetMembers(currentMapperData.TargetType)
.FirstOrDefault(m => m.Name == memberNamePart);
if (matchingTargetMember == null)
{
matchingTargetMember = GlobalContext.Instance
.MemberCache
.GetSourceMembers(currentMapperData.SourceType)
.FirstOrDefault(m => m.Name == memberNamePart);
if (matchingTargetMember == null)
{
return(false);
}
}
currentTargetMember = currentMapperData.TargetMember.Append(matchingTargetMember);
var childMemberMapperData = new ChildMemberMapperData(currentTargetMember, currentMapperData);
var memberMappingData = currentMappingData.GetChildMappingData(childMemberMapperData);
currentSourceMember = SourceMemberMatcher.GetMatchFor(
memberMappingData,
out _,
searchParentContexts: false);
if (currentSourceMember == null)
{
return(false);
}
currentMemberPart = new SourceMemberMetaMemberPart(
currentSourceMember,
currentMapperData,
isRootMemberPart: currentMemberPart == null);
currentMappingDataFactory = (sm, tm, md, c) =>
{
var mappingData = ObjectMappingDataFactory.ForChild(sm, tm, 0, md);
return(sm.IsEnumerable
? ObjectMappingDataFactory.ForElement(mappingData)
: ObjectMappingDataFactory.ForChild(sm, tm, 0, md));
};
break;
}
if (metaMember == null)
{
metaMember = currentMemberPart;
continue;
}
if (!metaMember.TrySetNextPart(currentMemberPart))
{
return(false);
}
}
return(true);
}
public Expression GetNewObjectCreation(IObjectMappingData mappingData)
{
var objectCreation = _constructorsCache.GetOrAdd(new ConstructionKey(mappingData), key =>
{
var mapperData = key.MappingData.MapperData;
var constructions = new List <Construction>();
var newingConstructorRequired = true;
var configuredFactories = mapperData
.MapperContext
.UserConfigurations
.GetObjectFactories(mapperData);
foreach (var configuredFactory in configuredFactories)
{
var configuredConstruction = new Construction(configuredFactory, mapperData);
constructions.Add(configuredConstruction);
if (configuredConstruction.IsUnconditional)
{
newingConstructorRequired = false;
break;
}
}
if (newingConstructorRequired)
{
var greediestAvailableConstructor = mapperData.InstanceVariable.Type
.GetPublicInstanceConstructors()
.Select(ctor => new ConstructorData(
ctor,
ctor.GetParameters()
.Select(p =>
{
var parameterMapperData = new ChildMemberMapperData(
mapperData.TargetMember.Append(Member.ConstructorParameter(p)),
mapperData);
return(key.MappingData.GetChildMappingData(parameterMapperData));
})
.Select(memberMappingData =>
{
var dataSources = mapperData
.MapperContext
.DataSources
.FindFor(memberMappingData);
return(Tuple.Create(memberMappingData.MapperData.TargetMember, dataSources));
})
.ToArray()))
.Where(ctor => ctor.CanBeConstructed)
.OrderByDescending(ctor => ctor.NumberOfParameters)
.FirstOrDefault();
if (greediestAvailableConstructor != null)
{
foreach (var memberAndDataSourceSet in greediestAvailableConstructor.ArgumentDataSources)
{
key.MappingData.MapperData.RegisterTargetMemberDataSourcesIfRequired(
memberAndDataSourceSet.Item1,
memberAndDataSourceSet.Item2);
}
constructions.Add(greediestAvailableConstructor.Construction);
}
}
if (constructions.None())
{
key.MappingData = null;
return(null);
}
var compositeConstruction = new Construction(constructions, key);
key.MappingData = null;
return(compositeConstruction);
});
if (objectCreation == null)
{
return(null);
}
mappingData.MapperData.Context.UsesMappingDataObjectAsParameter = objectCreation.UsesMappingDataObjectParameter;
var creationExpression = objectCreation.GetConstruction(mappingData);
return(creationExpression);
}