/// <summary>
/// If there is a MemberInitExpression 'new Person { ID = p.ID, Friend = new Person { ID = p.Friend.ID }}'
/// or a NewExpression 'new { ID = p.ID, Friend = new { ID = p.Friend.ID }}',
/// this method validates against the RHS of the member assignment, the expression "p.ID" for example.
/// </summary>
/// <param name="expressionToAssign">The expression to validate.</param>
/// <param name="initType">Type of the MemberInit or the New expression.</param>
/// <param name="previousNested">The outer nested initializer of the current initializer we are checking.</param>
/// <returns>true if the expression to assign is fine; false otherwise.</returns>
private bool CheckCompatibleAssignmentExpression(Expression expressionToAssign, Type initType, ref MemberAssignmentAnalysis previousNested)
{
MemberAssignmentAnalysis nested = MemberAssignmentAnalysis.Analyze(this.entity, expressionToAssign);
if (nested.MultiplePathsFound)
{
this.multiplePathsFound = true;
return(false);
}
// When we're visiting a nested entity initializer, we're exactly one level above that.
Exception incompatibleException = nested.CheckCompatibleAssignments(initType, ref previousNested);
if (incompatibleException != null)
{
this.incompatibleAssignmentsException = incompatibleException;
return(false);
}
if (this.pathFromEntity.Count == 0)
{
this.pathFromEntity.AddRange(nested.GetExpressionsToTargetEntity());
}
return(true);
}
/// <summary>Analyzes the specified member-init expression.</summary>
/// <param name="mie">Expression to analyze.</param>
/// <param name="pb">Path-tracking object to store analysis in.</param>
/// <param name="context">Context of expression to analyze.</param>
internal static void Analyze(MemberInitExpression mie, SelectExpandPathBuilder pb, DataServiceContext context)
{
Debug.Assert(mie != null, "mie != null");
var epa = new EntityProjectionAnalyzer(pb, mie.Type, context);
MemberAssignmentAnalysis targetEntityPath = null;
foreach (MemberBinding mb in mie.Bindings)
{
MemberAssignment ma = mb as MemberAssignment;
epa.Visit(ma.Expression);
if (ma != null)
{
var analysis = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, ma.Expression);
if (analysis.IncompatibleAssignmentsException != null)
{
throw analysis.IncompatibleAssignmentsException;
}
// Note that an "empty" assignment on the binding is not checked/handled,
// because the funcletizer would have turned that into a constant
// in the tree, the visit earlier in this method would have thrown
// an exception at finding a constant in an entity projection.
//
// We do account however for failing to find a reference off the
// parameter entry to detect errors like this: new ET() { Ref = e }
// Here it looks like the new ET should be the parent of 'e', but
// there is nothing in scope that represents that.
//
// This also explains while error messages might be a bit misleading
// in this case (because they reference a constant when the user
// hasn't included any).
Type targetType = ClientTypeUtil.GetMemberType(ma.Member);
Expression[] lastExpressions = analysis.GetExpressionsBeyondTargetEntity();
if (lastExpressions.Length == 0)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(targetType, ma.Expression));
}
MemberExpression lastExpression = lastExpressions[lastExpressions.Length - 1] as MemberExpression;
Debug.Assert(
!analysis.MultiplePathsFound,
"!analysis.MultiplePathsFound -- the initilizer has been visited, and cannot be empty, and expressions that can combine paths should have thrown exception during initializer analysis");
#if DEBUG
Debug.Assert(
lastExpression != null,
"lastExpression != null -- the initilizer has been visited, and cannot be empty, and the only expressions that are allowed can be formed off the parameter, so this is always correlatd");
#endif
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
// For DataServiceStreamLink, the last expression will be a constant expression. Hence we won't be comparing name checks and entity checks for those type of bindings
if (lastExpression != null)
{
if (lastExpression.Member.Name != ma.Member.Name)
{
throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name));
}
// Unless we're initializing an entity, we should not traverse into the parameter in scope.
bool targetIsEntity = ClientTypeUtil.TypeOrElementTypeIsEntity(targetType);
bool sourceIsEntity = ClientTypeUtil.TypeOrElementTypeIsEntity(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression));
}
}
}
}
}
