public IQualifiedMember RootSource <TSource, TTarget>()
{
var rootMember = _memberCache.GetOrAdd(
QualifiedMemberKey.Keys <TSource, TTarget> .Source,
k =>
{
var matchedTargetMember = RootTarget <TSource, TTarget>();
var sourceMember = QualifiedMember
.CreateRoot(Member.RootSource <TSource>(), _mapperContext)
.SetContext(matchedTargetMember.Context);
return(GetFinalSourceMember(sourceMember, matchedTargetMember));
});
return(rootMember);
}
public QualifiedMemberContext(
MappingRuleSet ruleSet,
Type sourceType,
Type targetType,
IQualifiedMember sourceMember,
QualifiedMember targetMember,
IQualifiedMemberContext parent,
MapperContext mapperContext)
: this(
ruleSet,
sourceType,
targetType,
targetMember,
parent,
mapperContext)
{
SourceMember = sourceMember.SetContext(this);
}
private static QualifiedMember CreateMember(
Expression memberAccessExpression,
Func <Type, Member> rootMemberFactory,
Func <Type, IList <Member> > membersFactory,
MapperContext mapperContext)
{
var expression = memberAccessExpression;
var memberAccesses = new List <Expression>();
while (expression.NodeType != ExpressionType.Parameter)
{
var memberExpression = GetMemberAccess(expression);
memberAccesses.Insert(0, memberExpression);
expression = memberExpression.GetParentOrNull();
}
AdjustMemberAccessesIfRootedInMappingData(memberAccesses, ref expression);
var rootMember = rootMemberFactory.Invoke(expression.Type);
var parentMember = rootMember;
var memberChain = new Member[memberAccesses.Count + 1];
memberChain[0] = rootMember;
for (var i = 0; i < memberAccesses.Count; i++)
{
var memberAccess = memberAccesses[i];
var memberName = GetMemberName(memberAccess);
var members = membersFactory.Invoke(parentMember.Type);
var member = members.FirstOrDefault(m => m.Name == memberName);
if (member == null)
{
return(null);
}
memberChain[i + 1] = member;
parentMember = member;
}
return(QualifiedMember.From(memberChain, mapperContext));
}
private QualifiedMember(Member member, QualifiedMember parent, MapperContext mapperContext)
: this(member, mapperContext)
{
var memberMatchingNames = mapperContext.Naming.GetMatchingNamesFor(member);
if (parent == null)
{
MemberChain = new[] { member };
JoinedNames = memberMatchingNames;
_pathFactory = () => MemberChain[0].JoiningName;
return;
}
MemberChain = parent.MemberChain.Append(member);
JoinedNames = parent.JoinedNames.ExtendWith(memberMatchingNames, mapperContext);
_pathFactory = () => parent.GetPath() + member.JoiningName;
IsRecursion = DetermineRecursion();
}
private static bool TargetMemberEverRepeatsWithin(QualifiedMember parentMember, IQualifiedMember subjectMember)
{
while (true)
{
var nonSimpleChildMembers = GetTargetMembers(parentMember.Type)
.Filter(m => !m.IsSimple)
.ToArray();
if (nonSimpleChildMembers.None())
{
return(false);
}
var sameTypedChildMembers = nonSimpleChildMembers
.Filter(subjectMember, (sm, cm) => (cm.IsEnumerable ? cm.ElementType : cm.Type) == sm.Type)
.ToArray();
if (sameTypedChildMembers
.Project(parentMember, GetNonEnumerableChildMember)
.Any(cm => cm != subjectMember))
{
return(true);
}
foreach (var childMember in nonSimpleChildMembers)
{
var qualifiedChildMember = GetNonEnumerableChildMember(parentMember, childMember);
if (qualifiedChildMember.IsRecursion)
{
continue;
}
if (TargetMemberEverRepeatsWithin(qualifiedChildMember, subjectMember))
{
return(true);
}
}
return(false);
}
}
private QualifiedMember(Member member, QualifiedMember parent, MapperContext mapperContext)
: this(member, mapperContext)
{
if (parent == null)
{
MemberChain = new[] { member };
JoinedNames = NamingSettings.RootMatchingNames;
_pathFactory = m => m.LeafMember.JoiningName;
return;
}
_parent = parent;
MemberChain = parent.MemberChain.Append(member);
var memberMatchingNames = mapperContext.Naming.GetMatchingNamesFor(member, parent.Context);
JoinedNames = parent.JoinedNames.ExtendWith(memberMatchingNames, mapperContext);
_pathFactory = m => m._parent.GetPath() + m.LeafMember.JoiningName;
IsRecursion = DetermineRecursion();
}
public static bool IsUnmappable(this QualifiedMember member, out string reason)
{
if (IsStructNonSimpleMember(member))
{
reason = member.Type.GetFriendlyName() + " member on a struct";
return(true);
}
if (member.LeafMember.MemberType == MemberType.SetMethod)
{
reason = null;
return(false);
}
if (!member.IsReadOnly)
{
reason = null;
return(false);
}
if (member.Type.IsArray)
{
reason = "readonly array";
return(true);
}
if (member.IsSimple || member.Type.IsValueType())
{
reason = "readonly " + ((member.IsComplex) ? "struct" : member.Type.GetFriendlyName());
return(true);
}
if (member.IsEnumerable && member.Type.IsClosedTypeOf(typeof(ReadOnlyCollection <>)))
{
reason = "readonly " + member.Type.GetFriendlyName();
return(true);
}
reason = null;
return(false);
}
private static QualifiedMember CreateMember(
Expression memberAccessExpression,
Func <Type, Member> rootMemberFactory,
Func <Type, IList <Member> > membersFactory,
Action <ExpressionType> nonMemberAction,
MapperContext mapperContext)
{
var memberAccesses = memberAccessExpression.GetMemberAccessChain(nonMemberAction, out var rootExpression);
if (memberAccesses.None())
{
return(null);
}
var rootMember = rootMemberFactory.Invoke(rootExpression.Type);
var parentMember = rootMember;
var memberChain = new Member[memberAccesses.Count + 1];
memberChain[0] = rootMember;
for (var i = 0; i < memberAccesses.Count;)
{
var memberAccess = memberAccesses[i++];
var memberName = GetMemberName(memberAccess);
var members = membersFactory.Invoke(parentMember.Type);
var member = members.FirstOrDefault(memberName, (mn, m) => m.Name == mn);
if (member == null)
{
return(null);
}
memberChain[i] = member;
parentMember = member;
}
return(QualifiedMember.From(memberChain, mapperContext));
}
public static bool HasCompatibleTypes <TOtherTypePair>(
this ITypePair typePair,
TOtherTypePair otherTypePair,
IQualifiedMember sourceMember = null,
QualifiedMember targetMember = null)
where TOtherTypePair : ITypePair
{
var sourceTypesMatch =
typePair.IsForSourceType(otherTypePair.SourceType) ||
(sourceMember?.HasCompatibleType(typePair.SourceType) == true);
if (!sourceTypesMatch)
{
return(false);
}
var targetTypesMatch =
(targetMember?.HasCompatibleType(typePair.TargetType) == true) ||
otherTypePair.TargetType.IsAssignableTo(typePair.TargetType);
return(targetTypesMatch);
}
public static bool TargetMemberIsUnmappable <TTypePair>(
this TTypePair typePair,
QualifiedMember targetMember,
Func <TTypePair, IEnumerable <ConfiguredDataSourceFactory> > configuredDataSourcesFactory,
out string reason)
where TTypePair : ITypePair
{
if (targetMember == QualifiedMember.All)
{
reason = null;
return(false);
}
if ((typePair.TargetType != typePair.SourceType) &&
targetMember.LeafMember.IsEntityId() &&
configuredDataSourcesFactory.Invoke(typePair).None())
{
reason = "Entity key member";
return(true);
}
return(targetMember.IsUnmappable(out reason));
}
public QualifiedMemberContext(
MappingRuleSet ruleSet,
Type sourceType,
Type targetType,
QualifiedMember targetMember,
IQualifiedMemberContext parent,
MapperContext mapperContext)
{
if (parent == null)
{
IsRoot = true;
}
else
{
_parent = parent;
}
SourceType = sourceType;
TargetType = targetType;
RuleSet = ruleSet;
MapperContext = mapperContext;
TargetMember = (targetMember?.SetContext(this)) ?? QualifiedMember.All;
}
public static bool TargetMemberIsUnmappable <TTMapperData>(
this TTMapperData mapperData,
QualifiedMember targetMember,
Func <TTMapperData, IEnumerable <ConfiguredDataSourceFactory> > configuredDataSourcesFactory,
UserConfigurationSet userConfigurations,
out string reason)
where TTMapperData : IBasicMapperData
{
if (targetMember == QualifiedMember.All)
{
reason = null;
return(false);
}
if (!targetMember.LeafMember.IsEntityId() ||
userConfigurations.MapEntityKeys(mapperData) ||
configuredDataSourcesFactory.Invoke(mapperData).Any())
{
return(targetMember.IsUnmappable(out reason));
}
// If we're here:
// 1. TargetMember is an Entity key
// 2. The rule set doesn't allow entity key mapping
// 3. No configuration exists to allow Entity key Mapping
// 4. No configured data sources exist
if (mapperData.RuleSet.Settings.AllowCloneEntityKeyMapping &&
(mapperData.SourceType == mapperData.TargetType))
{
return(targetMember.IsUnmappable(out reason));
}
reason = "Entity key member";
return(true);
}
public static bool IsConstructorParameter(this QualifiedMember member) => member.LeafMember.MemberType == MemberType.ConstructorParameter;
public static bool IsEnumerableElement(this QualifiedMember member) => member.LeafMember.IsEnumerableElement();
public static Expression GetAccess(this QualifiedMember member, IMemberMapperData mapperData) => member.GetAccess(mapperData.TargetInstance, mapperData);
public static Expression GetEmptyInstanceCreation(this QualifiedMember member) => member.Type.GetEmptyInstanceCreation(member.ElementType);
public bool CouldMatch(QualifiedMember otherMember) => _matchedTargetMemberJoinedNames.CouldMatch(otherMember.JoinedNames);
public bool CouldMatch(QualifiedMember otherMember)
{
throw new NotImplementedException();
}
public static QualifiedMember GetElementMember(this QualifiedMember enumerableMember) => enumerableMember.Append(GetElementMember(enumerableMember.Type));
public ChildMemberMapperData(QualifiedMember targetMember, ObjectMapperData parent)
: base(parent.RuleSet, parent.SourceType, parent.TargetType, targetMember, parent)
{
Parent = parent;
Context = new MapperDataContext(this);
}
private QualifiedMember CreateFinalMember(QualifiedMember member)
{
return(member.IsTargetMember
? _mapperContext.QualifiedMemberFactory.GetFinalTargetMember(member)
: member);
}
public bool CouldMatch(QualifiedMember otherMember) => JoinedNames.CouldMatch(otherMember.JoinedNames);
public bool CouldMatch(QualifiedMember otherMember) => _matchedTargetMember.CouldMatch(otherMember);