private void AddInclude(SimpleType source, MemberExpression memberSelector, LambdaExpression collectionInclude)
{
var members = source.GetAllMembers();
if (members.Count > 0 && memberSelector.GetDepth() > 1)
{
var innermostMember = ExpressionUtil.GetInnermostMemberExpression(memberSelector);
foreach (var kvp in members)
{
if (kvp.Key == innermostMember.Member)
{
AddInclude(kvp.Value, ExpressionUtil.ReplaceInnermostMemberExpressionWithParameter(memberSelector) as MemberExpression, collectionInclude);
return;
}
}
}
else
{
var parameter = ExpressionUtil.GetParameterExpression(memberSelector);
if (collectionInclude != null)
{
source.Includes.Add(IncludeDirectiveUtil.GetIncludeInCollectionDirective(memberSelector, collectionInclude));
}
else
{
source.Includes.Add(IncludeDirectiveUtil.GetIncludeDirective(memberSelector));
}
}
}
protected virtual List <IncludeDirective> GetMemberIncludes(MemberExpression memberExp)
{
var newIncludes = new List <IncludeDirective>();
var memberIsNotCollection = !TypesUtil.IsNonPrimitiveCollection(memberExp.Type);
Includes.ForEach(inc =>
{
var includeExpression = inc.GetSelector().Body as MemberExpression;
if (memberIsNotCollection)
{
var innermostMember = ExpressionUtil.GetInnermostMemberExpression(includeExpression);
if (innermostMember.Member == memberExp.Member && includeExpression.Expression is MemberExpression)
{
var slicedExpression = ExpressionUtil.ReplaceInnermostMemberExpressionWithParameter(includeExpression) as MemberExpression;
if (inc is IIncludeInCollectionDirective)
{
newIncludes.Add(IncludeDirectiveUtil.GetIncludeInCollectionDirective(slicedExpression,
(inc as IIncludeInCollectionDirective).GetFieldSelector()));
}
else
{
newIncludes.Add(IncludeDirectiveUtil.GetIncludeDirective(slicedExpression));
}
}
}
else
{
if (inc is IIncludeInCollectionDirective && ExpressionUtil.IsEquivalent(inc.GetSelector().Body, memberExp))
{
newIncludes.Add(IncludeDirectiveUtil.GetIncludeDirective
((inc as IIncludeInCollectionDirective).GetFieldSelector()));
}
}
});
return(newIncludes);
}
private List <IncludeBinding> GetIncludeBindings(IEnumerable <QueryBinding> queryBindings)
{
var bindings = new List <IncludeBinding>();
Func <MemberExpression, IncludeBinding> getExistingBinding =
m => bindings.Find(id => ExpressionUtil.IsEquivalent(id.IncludeDirective.GetSelector().Body, m));
Func <MemberExpression, IncludeDirective> getIncludeDirective = m =>
{
var member = m.GetDepth() == 1 ? m :
Expression.MakeMemberAccess(Expression.Parameter(m.Expression.Type, m.Expression.Type.Name.Substring(0, 1).ToLower()), m.Member);
return(IncludeDirectiveUtil.GetIncludeDirective(member));
};
foreach (var qb in queryBindings)
{
//Allowing not included collections to be used for collection includes
foreach (var include in qb.Value.Includes)//.Where(inc => !(inc is IIncludeInCollectionDirective)))
{
IRequestedBinding targetBinding = qb;
foreach (MemberExpression member in GetMembers(include.GetSelector().Body as MemberExpression))
{
var existingBinding = getExistingBinding(member);
if (existingBinding != null)
{
targetBinding = existingBinding;
}
else
{
var includeDirective = getIncludeDirective(member);
var currentMemberName = (targetBinding is QueryBinding)
? (targetBinding as QueryBinding).Value.GetMemberName(member.Member) : member.Member.Name;
var binding = new IncludeBinding()
{
IncludeDirective = includeDirective,
TargetBinding = targetBinding,
TranslatedExpression = typeTranslationUtil.GetTranslatedMemberExpression
(member.Expression.Type, currentMemberName, targetBinding.TranslatedExpression)
};
bindings.Add(binding);
targetBinding = binding;
}
}
}
foreach (var collInclude in qb.Value.Includes.Where(inc => inc is IIncludeInCollectionDirective))
{
var collectionSelector = collInclude.GetSelector().Body as MemberExpression;
var target = getExistingBinding(collectionSelector);
if (target != null)
{
bindings.Add(new UnprojectedIncludeInCollectionBinding
{
IncludeDirective = collInclude,
TargetBinding = target
});
}
}
}
return(bindings);
}
