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(); }
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); } }
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)); } } } }
private NonEntityProjectionAnalyzer(PathBox pb, Type type, DataServiceContext context) { this.box = pb; this.type = type; this.context = context; }
/// <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); }
/// <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); } }
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(); }