internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
default:
// ExpressionType.MemberAccess as a top-level expression is correctly
// processed here, as the lambda isn't being member-initialized.
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
default:
// ExpressionType.MemberAccess as a top-level expression is correctly
// processed here, as the lambda isn't being member-initialized.
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
private static void Analyze(LambdaExpression e, PathBox pb, DataServiceContext context)
{
bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(e.Body.Type);
ParameterExpression pe = e.Parameters.Last<ParameterExpression>();
bool flag2 = ClientTypeUtil.TypeOrElementTypeIsEntity(pe.Type);
if (flag2)
{
pb.PushParamExpression(pe);
}
if (!flag)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.Constant:
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotCreateConstantEntity);
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression) e.Body, pb, context);
goto Label_0099;
case ExpressionType.New:
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotConstructKnownEntityTypes);
}
NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context);
}
Label_0099:
if (flag2)
{
pb.PopParamExpression();
}
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
default:
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
internal static void Analyze(LambdaExpression e, PathBox pb)
{
bool knownEntityType = ClientType.CheckElementTypeIsEntity(e.Body.Type);
pb.PushParamExpression(e.Parameters.Last());
if (!knownEntityType)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb);
break;
case ExpressionType.New:
throw new NotSupportedException(Strings.ALinq_CannotConstructKnownEntityTypes);
case ExpressionType.Constant:
throw new NotSupportedException(Strings.ALinq_CannotCreateConstantEntity);
default:
NonEntityProjectionAnalyzer.Analyze(e.Body, pb);
break;
}
}
pb.PopParamExpression();
}
private static void AnalyzeResourceExpression(LambdaExpression lambda, ResourceExpression resource)
{
PathBox pb = new PathBox();
ProjectionAnalyzer.Analyze(lambda, pb);
resource.Projection = new ProjectionQueryOptionExpression(lambda.Body.Type, lambda, pb.ProjectionPaths.ToList());
resource.ExpandPaths = pb.ExpandPaths.Union(resource.ExpandPaths, StringComparer.Ordinal).ToList();
}
private EntityProjectionAnalyzer(PathBox pb, Type type)
{
Debug.Assert(pb != null, "pb != null");
Debug.Assert(type != null, "type != null");
this.box = pb;
this.type = type;
}
private static void AnalyzeResourceExpression(LambdaExpression lambda, ResourceExpression resource, DataServiceContext context)
{
PathBox pb = new PathBox();
Analyze(lambda, pb, context);
resource.Projection = new ProjectionQueryOptionExpression(lambda.Body.Type, lambda, pb.ProjectionPaths.ToList <string>());
resource.ExpandPaths = pb.ExpandPaths.Union <string>(resource.ExpandPaths, StringComparer.Ordinal).ToList <string>();
resource.RaiseUriVersion(pb.UriVersion);
}
/// <summary>Initializes a new <see cref="EntityProjectionAnalyzer"/> instance.</summary>
/// <param name="pb">Path-tracking object.</param>
/// <param name="type">Type being member-init'ed.</param>
/// <param name="context">Context of expression to analyze.</param>
private EntityProjectionAnalyzer(PathBox pb, Type type, DataServiceContext context)
{
Debug.Assert(pb != null, "pb != null");
Debug.Assert(type != null, "type != null");
this.box = pb;
this.type = type;
this.context = context;
}
private static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context)
{
if (ClientTypeUtil.TypeOrElementTypeIsEntity(mie.Type))
{
EntityProjectionAnalyzer.Analyze(mie, pb, context);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb, context);
}
}
private static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context)
{
if (ClientTypeUtil.TypeOrElementTypeIsEntity(mie.Type))
{
EntityProjectionAnalyzer.Analyze(mie, pb, context);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb, context);
}
}
internal static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
var epa = new EntityProjectionAnalyzer(pb, mie.Type);
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;
}
Type targetType = 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");
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");
if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name))
{
throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name));
}
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType);
bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression));
}
}
}
}
/// <summary>
/// Analyzes the specified expression with an entity-projection or
/// non-entity-projection analyzer.
/// </summary>
/// <param name="mie">Expression to analyze.</param>
/// <param name="pb">Path box where select and expand paths are tracked.</param>
/// <param name="context">Context of expression to analyze.</param>
private static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context)
{
Debug.Assert(mie != null, "mie != null");
Debug.Assert(pb != null, "pb != null");
bool knownEntityType = ClientTypeUtil.TypeOrElementTypeIsEntity(mie.Type);
if (knownEntityType)
{
EntityProjectionAnalyzer.Analyze(mie, pb, context);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb, context);
}
}
private static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
Debug.Assert(pb != null, "pb != null");
bool knownEntityType = ClientType.CheckElementTypeIsEntity(mie.Type);
if (knownEntityType)
{
EntityProjectionAnalyzer.Analyze(mie, pb);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb);
}
}
internal static void Analyze(Expression e, PathBox pb, DataServiceContext context)
{
ProjectionAnalyzer.NonEntityProjectionAnalyzer analyzer = new ProjectionAnalyzer.NonEntityProjectionAnalyzer(pb, e.Type, context);
MemberInitExpression expression = e as MemberInitExpression;
if (expression != null)
{
foreach (MemberBinding binding in expression.Bindings)
{
MemberAssignment assignment = binding as MemberAssignment;
if (assignment != null)
{
analyzer.Visit(assignment.Expression);
}
}
}
else
{
analyzer.Visit(e);
}
}
internal static void Analyze(Expression e, PathBox pb)
{
var nepa = new NonEntityProjectionAnalyzer(pb, e.Type);
MemberInitExpression mie = e as MemberInitExpression;
if (mie != null)
{
foreach (MemberBinding mb in mie.Bindings)
{
MemberAssignment ma = mb as MemberAssignment;
if (ma != null)
{
nepa.Visit(ma.Expression);
}
}
}
else
{
nepa.Visit(e);
}
}
internal static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context)
{
ProjectionAnalyzer.EntityProjectionAnalyzer analyzer = new ProjectionAnalyzer.EntityProjectionAnalyzer(pb, mie.Type, context);
MemberAssignmentAnalysis previous = null;
foreach (MemberBinding binding in mie.Bindings)
{
MemberAssignment assignment = binding as MemberAssignment;
analyzer.Visit(assignment.Expression);
if (assignment != null)
{
MemberAssignmentAnalysis analysis2 = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, assignment.Expression);
if (analysis2.IncompatibleAssignmentsException != null)
{
throw analysis2.IncompatibleAssignmentsException;
}
Type memberType = ClientTypeUtil.GetMemberType(assignment.Member);
Expression[] expressionsBeyondTargetEntity = analysis2.GetExpressionsBeyondTargetEntity();
if (expressionsBeyondTargetEntity.Length == 0)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(memberType, assignment.Expression));
}
MemberExpression expression = expressionsBeyondTargetEntity[expressionsBeyondTargetEntity.Length - 1] as MemberExpression;
analysis2.CheckCompatibleAssignments(mie.Type, ref previous);
if (expression != null)
{
if (expression.Member.Name != assignment.Member.Name)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_PropertyNamesMustMatchInProjections(expression.Member.Name, assignment.Member.Name));
}
bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(memberType);
if (ClientTypeUtil.TypeOrElementTypeIsEntity(expression.Type) && !flag)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjection(memberType, assignment.Expression));
}
}
}
}
}
private static void Analyze(LambdaExpression e, PathBox pb, DataServiceContext context)
{
bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(e.Body.Type);
ParameterExpression pe = e.Parameters.Last <ParameterExpression>();
bool flag2 = ClientTypeUtil.TypeOrElementTypeIsEntity(pe.Type);
if (flag2)
{
pb.PushParamExpression(pe);
}
if (!flag)
{
NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context);
}
else
{
switch (e.Body.NodeType)
{
case ExpressionType.Constant:
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotCreateConstantEntity);
case ExpressionType.MemberInit:
EntityProjectionAnalyzer.Analyze((MemberInitExpression)e.Body, pb, context);
goto Label_0099;
case ExpressionType.New:
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_CannotConstructKnownEntityTypes);
}
NonEntityProjectionAnalyzer.Analyze(e.Body, pb, context);
}
Label_0099:
if (flag2)
{
pb.PopParamExpression();
}
}
/// <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>
internal static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
var epa = new EntityProjectionAnalyzer(pb, mie.Type);
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 = 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");
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");
if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name))
{
throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name));
}
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
// Unless we're initializing an entity, we should not traverse into the parameter in scope.
bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType);
bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression));
}
}
}
}
internal static void Analyze(MemberInitExpression mie, PathBox pb, DataServiceContext context)
{
ProjectionAnalyzer.EntityProjectionAnalyzer analyzer = new ProjectionAnalyzer.EntityProjectionAnalyzer(pb, mie.Type, context);
MemberAssignmentAnalysis previous = null;
foreach (MemberBinding binding in mie.Bindings)
{
MemberAssignment assignment = binding as MemberAssignment;
analyzer.Visit(assignment.Expression);
if (assignment != null)
{
MemberAssignmentAnalysis analysis2 = MemberAssignmentAnalysis.Analyze(pb.ParamExpressionInScope, assignment.Expression);
if (analysis2.IncompatibleAssignmentsException != null)
{
throw analysis2.IncompatibleAssignmentsException;
}
Type memberType = ClientTypeUtil.GetMemberType(assignment.Member);
Expression[] expressionsBeyondTargetEntity = analysis2.GetExpressionsBeyondTargetEntity();
if (expressionsBeyondTargetEntity.Length == 0)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(memberType, assignment.Expression));
}
MemberExpression expression = expressionsBeyondTargetEntity[expressionsBeyondTargetEntity.Length - 1] as MemberExpression;
analysis2.CheckCompatibleAssignments(mie.Type, ref previous);
if (expression != null)
{
if (expression.Member.Name != assignment.Member.Name)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_PropertyNamesMustMatchInProjections(expression.Member.Name, assignment.Member.Name));
}
bool flag = ClientTypeUtil.TypeOrElementTypeIsEntity(memberType);
if (ClientTypeUtil.TypeOrElementTypeIsEntity(expression.Type) && !flag)
{
throw new NotSupportedException(System.Data.Services.Client.Strings.ALinq_ExpressionNotSupportedInProjection(memberType, assignment.Expression));
}
}
}
}
}
private NonEntityProjectionAnalyzer(PathBox pb, Type type, DataServiceContext context)
{
this.box = pb;
this.type = type;
this.context = context;
}
internal static void Analyze(Expression e, PathBox pb, DataServiceContext context)
{
ProjectionAnalyzer.NonEntityProjectionAnalyzer analyzer = new ProjectionAnalyzer.NonEntityProjectionAnalyzer(pb, e.Type, context);
MemberInitExpression expression = e as MemberInitExpression;
if (expression != null)
{
foreach (MemberBinding binding in expression.Bindings)
{
MemberAssignment assignment = binding as MemberAssignment;
if (assignment != null)
{
analyzer.Visit(assignment.Expression);
}
}
}
else
{
analyzer.Visit(e);
}
}
/// <summary>Initializes a new <see cref="EntityProjectionAnalyzer"/> instance.</summary>
/// <param name="pb">Path-tracking object.</param>
/// <param name="type">Type being member-init'ed.</param>
private EntityProjectionAnalyzer(PathBox pb, Type type)
{
Debug.Assert(pb != null, "pb != null");
Debug.Assert(type != null, "type != null");
this.box = pb;
this.type = type;
}
private static void AnalyzeResourceExpression(LambdaExpression lambda, ResourceExpression resource, DataServiceContext context)
{
PathBox pb = new PathBox();
Analyze(lambda, pb, context);
resource.Projection = new ProjectionQueryOptionExpression(lambda.Body.Type, lambda, pb.ProjectionPaths.ToList<string>());
resource.ExpandPaths = pb.ExpandPaths.Union<string>(resource.ExpandPaths, StringComparer.Ordinal).ToList<string>();
resource.RaiseUriVersion(pb.UriVersion);
}
internal static void Analyze(Expression e, PathBox pb)
{
var nepa = new NonEntityProjectionAnalyzer(pb, e.Type);
MemberInitExpression mie = e as MemberInitExpression;
if (mie != null)
{
foreach (MemberBinding mb in mie.Bindings)
{
MemberAssignment ma = mb as MemberAssignment;
if (ma != null)
{
nepa.Visit(ma.Expression);
}
}
}
else
{
nepa.Visit(e);
}
}
/// <summary>
/// Analyzes the specified expression with an entity-projection or
/// non-entity-projection analyzer.
/// </summary>
/// <param name="mie">Expression to analyze.</param>
/// <param name="pb">Path box where select and expand paths are tracked.</param>
private static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
Debug.Assert(pb != null, "pb != null");
bool knownEntityType = ClientType.CheckElementTypeIsEntity(mie.Type);
if (knownEntityType)
{
EntityProjectionAnalyzer.Analyze(mie, pb);
}
else
{
NonEntityProjectionAnalyzer.Analyze(mie, pb);
}
}
/// <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>
internal static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
var epa = new EntityProjectionAnalyzer(pb, mie.Type);
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 = 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");
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");
if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name))
{
throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name));
}
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
// Unless we're initializing an entity, we should not traverse into the parameter in scope.
bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType);
bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression));
}
}
}
}
internal static void Analyze(MemberInitExpression mie, PathBox pb)
{
Debug.Assert(mie != null, "mie != null");
var epa = new EntityProjectionAnalyzer(pb, mie.Type);
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;
}
Type targetType = 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");
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");
if (lastExpression != null && (lastExpression.Member.Name != ma.Member.Name))
{
throw new NotSupportedException(Strings.ALinq_PropertyNamesMustMatchInProjections(lastExpression.Member.Name, ma.Member.Name));
}
analysis.CheckCompatibleAssignments(mie.Type, ref targetEntityPath);
bool targetIsEntity = ClientType.CheckElementTypeIsEntity(targetType);
bool sourceIsEntity = ClientType.CheckElementTypeIsEntity(lastExpression.Type);
if (sourceIsEntity && !targetIsEntity)
{
throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(targetType, ma.Expression));
}
}
}
}
private NonEntityProjectionAnalyzer(PathBox pb, Type type)
{
this.box = pb;
this.type = type;
}
private NonEntityProjectionAnalyzer(PathBox pb, Type type, DataServiceContext context)
{
this.box = pb;
this.type = type;
this.context = context;
}
private NonEntityProjectionAnalyzer(PathBox pb, Type type)
{
this.box = pb;
this.type = type;
}
/// <summary>
/// Analyzes the specified <paramref name="lambda"/> for selection and updates
/// <paramref name="resource"/>.
/// </summary>
/// <param name="lambda">Lambda expression to analyze.</param>
/// <param name="resource">Resource expression to update.</param>
private static void AnalyzeResourceExpression(LambdaExpression lambda, ResourceExpression resource)
{
PathBox pb = new PathBox();
ProjectionAnalyzer.Analyze(lambda, pb);
resource.Projection = new ProjectionQueryOptionExpression(lambda.Body.Type, lambda, pb.ProjectionPaths.ToList());
resource.ExpandPaths = pb.ExpandPaths.Union(resource.ExpandPaths, StringComparer.Ordinal).ToList();
}
