/// <summary>constructor</summary> /// <param name="entity">entity</param> /// <param name="propertyName">name of collection or reference property to load</param> /// <param name="context">Originating context</param> /// <param name="request">Originating WebRequest</param> /// <param name="callback">user callback</param> /// <param name="state">user state</param> /// <param name="dataServiceRequest">request object.</param> /// <param name="plan">Projection plan for materialization; possibly null.</param> /// <param name="isContinuation">Whether this request is a continuation request.</param> internal LoadPropertyResult(object entity, string propertyName, DataServiceContext context, ODataRequestMessageWrapper request, AsyncCallback callback, object state, DataServiceRequest dataServiceRequest, ProjectionPlan plan, bool isContinuation) : base(context, Util.LoadPropertyMethodName, dataServiceRequest, request, new RequestInfo(context, isContinuation), callback, state) { this.entity = entity; this.propertyName = propertyName; this.plan = plan; }
internal static ProjectionPlan CompilePlan(LambdaExpression projection, Dictionary <Expression, Expression> normalizerRewrites) { Debug.Assert(projection != null, "projection != null"); Debug.Assert(projection.Parameters.Count == 1, "projection.Parameters.Count == 1"); Debug.Assert( projection.Body.NodeType == ExpressionType.Constant || projection.Body.NodeType == ExpressionType.MemberInit || projection.Body.NodeType == ExpressionType.MemberAccess || projection.Body.NodeType == ExpressionType.Convert || projection.Body.NodeType == ExpressionType.ConvertChecked || projection.Body.NodeType == ExpressionType.New, "projection.Body.NodeType == Constant, MemberInit, MemberAccess, Convert(Checked) New"); ProjectionPlanCompiler rewriter = new ProjectionPlanCompiler(normalizerRewrites); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Projection: " + projection); #endif Expression plan = rewriter.Visit(projection); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Becomes: " + plan); #endif ProjectionPlan result = new ProjectionPlan(); result.Plan = (Func <object, object, Type, object>)((LambdaExpression)plan).Compile(); result.ProjectedType = projection.Body.Type; #if DEBUG result.SourceProjection = projection; result.TargetProjection = plan; #endif return(result); }
internal static ProjectionPlan CompilePlan(LambdaExpression projection, Dictionary<Expression, Expression> normalizerRewrites) { Debug.Assert(projection != null, "projection != null"); Debug.Assert(projection.Parameters.Count == 1, "projection.Parameters.Count == 1"); Debug.Assert( projection.Body.NodeType == ExpressionType.Constant || projection.Body.NodeType == ExpressionType.MemberInit || projection.Body.NodeType == ExpressionType.MemberAccess || projection.Body.NodeType == ExpressionType.Convert || projection.Body.NodeType == ExpressionType.ConvertChecked || projection.Body.NodeType == ExpressionType.New, "projection.Body.NodeType == Constant, MemberInit, MemberAccess, Convert(Checked) New"); ProjectionPlanCompiler rewriter = new ProjectionPlanCompiler(normalizerRewrites); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Projection: " + projection); #endif Expression plan = rewriter.Visit(projection); #if TRACE_CLIENT_PROJECTIONS Trace.WriteLine("Becomes: " + plan); #endif ProjectionPlan result = new ProjectionPlan(); result.Plan = (Func<object, object, Type, object>)((LambdaExpression)plan).Compile(); result.ProjectedType = projection.Body.Type; #if DEBUG result.SourceProjection = projection; result.TargetProjection = plan; #endif return result; }
/// <summary>Create a request for a specific Uri</summary> /// <param name="queryComponents">The query components for the request</param> /// <param name="plan">Projection plan to reuse (possibly null).</param> internal DataServiceRequest(QueryComponents queryComponents, ProjectionPlan plan) { Debug.Assert(queryComponents != null, "queryComponents != null"); this.queryComponents = queryComponents; this.plan = plan; }
/// <summary>Initializes a new <see cref="DataServiceQueryContinuation"/> instance.</summary> /// <param name="nextLinkUri">URI to next page of data.</param> /// <param name="plan">Projection plan for results of next page.</param> internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(nextLinkUri != null, "nextLinkUri != null"); Debug.Assert(plan != null, "plan != null"); this.nextLinkUri = nextLinkUri; this.plan = plan; }
internal static DataServiceQueryContinuation Create(Uri nextLinkUri, ProjectionPlan plan) { if (nextLinkUri == null) { return(null); } return((DataServiceQueryContinuation)Util.ConstructorInvoke(typeof(DataServiceQueryContinuation <>).MakeGenericType(new Type[] { plan.ProjectedType }).GetInstanceConstructors(false).Single <ConstructorInfo>(), new object[] { nextLinkUri, plan })); }
internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(nextLinkUri != null, "nextLinkUri != null"); Debug.Assert(plan != null, "plan != null"); this.nextLinkUri = nextLinkUri; this.plan = plan; }
internal static DataServiceQueryContinuation Create(Uri nextLinkUri, ProjectionPlan plan) { if (nextLinkUri == null) { return null; } return (DataServiceQueryContinuation) Util.ConstructorInvoke(typeof(DataServiceQueryContinuation<>).MakeGenericType(new Type[] { plan.ProjectedType }).GetInstanceConstructors(false).Single<ConstructorInfo>(), new object[] { nextLinkUri, plan }); }
internal MaterializeAtom GetMaterializer(ProjectionPlan plan) { if (HttpStatusCode.NoContent != this.StatusCode) { return(this.CreateMaterializer(plan, ODataPayloadKind.Unsupported)); } return(MaterializeAtom.EmptyResults); }
/// <summary>Create a request for a specific Uri</summary> /// <param name="requestUri">The URI for the request.</param> /// <param name="queryComponents">The query components for the request</param> /// <param name="plan">Projection plan to reuse (possibly null).</param> internal DataServiceRequest(Uri requestUri, QueryComponents queryComponents, ProjectionPlan plan) : this(requestUri) { Debug.Assert(requestUri != null, "requestUri != null"); Debug.Assert(queryComponents != null, "queryComponents != null"); this.queryComponents = queryComponents; this.plan = plan; }
internal MaterializeAtom(ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind) { Type type; this.responseInfo = responseInfo; this.elementType = queryComponents.LastSegmentType; this.MergeOptionValue = responseInfo.MergeOption; this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(this.elementType); Type materializerType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.MaxProtocolVersion, out type); this.materializer = ODataMaterializer.CreateMaterializerForMessage(responseMessage, responseInfo, materializerType, queryComponents, plan, payloadKind); }
/// <summary>Initializes a new <see cref="DataServiceQueryContinuation"/> instance.</summary> /// <param name="nextLinkUri">URI to next page of data.</param> /// <param name="plan">Projection plan for results of next page.</param> internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(nextLinkUri != null, "nextLinkUri != null"); Debug.Assert(plan != null, "plan != null"); this.nextLinkUri = nextLinkUri; this.plan = plan; #if DEBUG this.deserializing = false; #endif }
/// <summary>Creates a new <see cref="DataServiceQueryContinuation"/> instance.</summary> /// <param name="nextLinkUri">Link to next page of data (possibly null).</param> /// <param name="plan">Plan to materialize the data (only null if nextLinkUri is null).</param> /// <returns>A new continuation object; null if nextLinkUri is null.</returns> internal static DataServiceQueryContinuation Create(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(plan != null || nextLinkUri == null, "plan != null || nextLinkUri == null"); if (nextLinkUri == null) { return(null); } var constructors = typeof(DataServiceQueryContinuation <>).MakeGenericType(plan.ProjectedType).GetInstanceConstructors(false /*isPublic*/); object result = Util.ConstructorInvoke(constructors.Single(), new object[] { nextLinkUri, plan }); return((DataServiceQueryContinuation)result); }
internal static DataServiceQueryContinuation Create(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(plan != null || nextLinkUri == null, "plan != null || nextLinkUri == null"); if (nextLinkUri == null) { return null; } var constructors = typeof(DataServiceQueryContinuation<>).MakeGenericType(plan.ProjectedType).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance); Debug.Assert(constructors.Length == 1, "constructors.Length == 1"); object result = Util.ConstructorInvoke(constructors[0], new object[] { nextLinkUri, plan }); return (DataServiceQueryContinuation)result; }
/// <summary>Creates a new <see cref="DataServiceQueryContinuation"/> instance.</summary> /// <param name="nextLinkUri">Link to next page of data (possibly null).</param> /// <param name="plan">Plan to materialize the data (only null if nextLinkUri is null).</param> /// <returns>A new continuation object; null if nextLinkUri is null.</returns> internal static DataServiceQueryContinuation Create(Uri nextLinkUri, ProjectionPlan plan) { Debug.Assert(plan != null || nextLinkUri == null, "plan != null || nextLinkUri == null"); if (nextLinkUri == null) { return(null); } var constructors = typeof(DataServiceQueryContinuation <>).MakeGenericType(plan.ProjectedType).GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance); Debug.Assert(constructors.Length == 1, "constructors.Length == 1"); object result = Util.ConstructorInvoke(constructors[0], new object[] { nextLinkUri, plan }); return((DataServiceQueryContinuation)result); }
internal MaterializeAtom GetMaterializer(DataServiceContext context, ProjectionPlan plan) { Debug.Assert(this.IsCompletedInternally, "request hasn't completed yet"); MaterializeAtom materializer; if (HttpStatusCode.NoContent != this.StatusCode) { materializer = DataServiceRequest.Materialize(context, this.ServiceRequest.QueryComponents, plan, this.ContentType, this.GetResponseStream()); } else { materializer = MaterializeAtom.EmptyResults; } return(materializer); }
/// <summary> /// Create materializer on top of response stream /// </summary> /// <param name="plan">Precompiled projection plan (possibly null).</param> /// <returns>A materializer instance ready to deserialize ther result</returns> internal MaterializeAtom GetMaterializer(ProjectionPlan plan) { Debug.Assert(this.IsCompletedInternally, "request hasn't completed yet"); MaterializeAtom materializer; if (HttpStatusCode.NoContent != this.StatusCode) { Debug.Assert(this.responseInfo != null, "The request didn't complete yet, we don't have a response info for it."); materializer = this.CreateMaterializer(plan, ODataPayloadKind.Unsupported); } else { materializer = MaterializeAtom.EmptyResults; } return materializer; }
internal static MaterializeAtom Materialize( ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, string contentType, IODataResponseMessage message, ODataPayloadKind expectedPayloadKind) { Debug.Assert(null != queryComponents, "querycomponents"); Debug.Assert(null != message, "message"); // If there is no content (For e.g. /Customers(1)/BestFriend is null), we need to return empty results. if (message.StatusCode == (int)HttpStatusCode.NoContent || String.IsNullOrEmpty(contentType)) { return(MaterializeAtom.EmptyResults); } return(new MaterializeAtom(responseInfo, queryComponents, plan, message, expectedPayloadKind)); }
#pragma warning restore 649 #endif #endregion Private fields /// <summary> /// constructor /// </summary> /// <param name="responseInfo">originating context</param> /// <param name="queryComponents">Query components (projection, expected type)</param> /// <param name="plan">Projection plan (if compiled in an earlier query).</param> /// <param name="responseMessage">responseMessage</param> /// <param name="payloadKind">The kind of the payload to materialize.</param> internal MaterializeAtom( ResponseInfo responseInfo, QueryComponents queryComponents, ProjectionPlan plan, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind) { Debug.Assert(queryComponents != null, "queryComponents != null"); this.responseInfo = responseInfo; this.elementType = queryComponents.LastSegmentType; this.expectingPrimitiveValue = PrimitiveType.IsKnownNullableType(elementType); Debug.Assert(responseMessage != null, "Response message is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?"); this.responseMessage = responseMessage; Type implementationType; Type materializerType = GetTypeForMaterializer(this.expectingPrimitiveValue, this.elementType, responseInfo.Model, out implementationType); this.materializer = ODataMaterializer.CreateMaterializerForMessage(responseMessage, responseInfo, materializerType, queryComponents, plan, payloadKind); }
/// <summary> /// Creates an instance of <see cref="MaterializeAtom"/> for the given plan. /// </summary> /// <param name="plan">The projection plan.</param> /// <param name="payloadKind">expected payload kind.</param> /// <returns>A new materializer instance</returns> private MaterializeAtom CreateMaterializer(ProjectionPlan plan, ODataPayloadKind payloadKind) { QueryComponents queryComponents = this.ServiceRequest.QueryComponents(this.responseInfo.Model); // In V2, in projection path, we did not check for assignability between the expected type and the type returned by the type resolver. if (plan != null || queryComponents.Projection != null) { this.RequestInfo.TypeResolver.IsProjectionRequest(); } var responseMessageWrapper = new HttpWebResponseMessage( new HeaderCollection(this.responseMessage), this.responseMessage.StatusCode, this.GetResponseStream, this.AllowDirectNetworkStreamReading ? this.responseMessage : null); // If AllowDirectNetworkStreamReading is true, the responseMessage will be disposed later when enumeration has finished. return DataServiceRequest.Materialize( this.responseInfo, queryComponents, plan, this.ContentType, responseMessageWrapper, payloadKind); }
private MaterializeAtom CreateMaterializer(ProjectionPlan plan, ODataPayloadKind payloadKind) { HttpWebResponseMessage message = new HttpWebResponseMessage(this.httpWebResponse, () => this.GetResponseStream()); return(DataServiceRequest.Materialize(this.responseInfo, this.ServiceRequest.QueryComponents(this.responseInfo.MaxProtocolVersion), plan, this.ContentType, message, payloadKind)); }
internal QueryOperationResponse <TElement> ProcessResult <TElement>(ProjectionPlan plan) { MaterializeAtom results = this.CreateMaterializer(plan, this.ServiceRequest.PayloadKind); return(this.GetResponse <TElement>(results)); }
#pragma warning restore 649 #endif #endregion Private fields. internal MaterializeAtom(DataServiceContext context, XmlReader reader, QueryComponents queryComponents, ProjectionPlan plan, MergeOption mergeOption) { Debug.Assert(queryComponents != null, "queryComponents != null"); this.context = context; this.elementType = queryComponents.LastSegmentType; this.MergeOptionValue = mergeOption; this.ignoreMissingProperties = context.IgnoreMissingProperties; this.reader = (reader == null) ? null : new System.Data.Services.Client.Xml.XmlAtomErrorReader(reader); this.countValue = CountStateInitial; this.expectingSingleValue = ClientConvert.IsKnownNullableType(elementType); Debug.Assert(reader != null, "Materializer reader is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?"); reader.Settings.NameTable.Add(context.DataNamespace); string typeScheme = this.context.TypeScheme.OriginalString; this.parser = new AtomParser(this.reader, AtomParser.XElementBuilderCallback, typeScheme, context.DataNamespace); AtomMaterializerLog log = new AtomMaterializerLog(this.context, mergeOption); Type implementationType; Type materializerType = GetTypeForMaterializer(this.expectingSingleValue, this.elementType, out implementationType); this.materializer = new AtomMaterializer(parser, context, materializerType, this.ignoreMissingProperties, mergeOption, log, this.MaterializedObjectCallback, queryComponents, plan); }
#pragma warning restore 649 #endif #endregion Private fields. /// <summary> /// constructor /// </summary> /// <param name="context">originating context</param> /// <param name="reader">reader</param> /// <param name="queryComponents">Query components (projection, expected type)</param> /// <param name="plan">Projection plan (if compiled in an earlier query).</param> /// <param name="mergeOption">merge option to use for this materialization pass</param> internal MaterializeAtom(DataServiceContext context, XmlReader reader, QueryComponents queryComponents, ProjectionPlan plan, MergeOption mergeOption) { Debug.Assert(queryComponents != null, "queryComponents != null"); this.context = context; this.elementType = queryComponents.LastSegmentType; this.MergeOptionValue = mergeOption; this.ignoreMissingProperties = context.IgnoreMissingProperties; this.reader = (reader == null) ? null : new System.Data.Services.Client.Xml.XmlAtomErrorReader(reader); this.countValue = CountStateInitial; this.expectingSingleValue = ClientConvert.IsKnownNullableType(elementType); Debug.Assert(reader != null, "Materializer reader is null! Did you mean to use Materializer.ResultsWrapper/EmptyResults?"); // NOTE: dataNamespace is used for reference equality, and while it looks like // a variable, it appears that it will only get set to XmlConstants.DataWebNamespace // at runtime. Therefore we remove string dataNamespace as a field here. // this.dataNamespace = reader != null ? reader.Settings.NameTable.Add(context.DataNamespace) : null; reader.Settings.NameTable.Add(context.DataNamespace); string typeScheme = this.context.TypeScheme.OriginalString; this.parser = new AtomParser(this.reader, AtomParser.XElementBuilderCallback, typeScheme, context.DataNamespace); AtomMaterializerLog log = new AtomMaterializerLog(this.context, mergeOption); Type implementationType; Type materializerType = GetTypeForMaterializer(this.expectingSingleValue, this.elementType, out implementationType); this.materializer = new AtomMaterializer(parser, context, materializerType, this.ignoreMissingProperties, mergeOption, log, this.MaterializedObjectCallback, queryComponents, plan); }
internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan) { this.nextLinkUri = nextLinkUri; this.plan = plan; }
public ODataEntriesEntityMaterializer(IEnumerable<ODataEntry> entries, ResponseInfo responseInfo, QueryComponents queryComponents, Type expectedType, ProjectionPlan materializeEntryPlan) : base(responseInfo, queryComponents, expectedType, materializeEntryPlan) { this.feedEntries = entries.GetEnumerator(); }
/// <summary> /// Processes the result for successfull request and produces the actual result of the request. /// </summary> /// <typeparam name="TElement">Element type of the result.</typeparam> /// <param name="plan">The plan to use for the projection, if available in precompiled form.</param> /// <returns>A instance of QueryResponseResult created on top of of the request.</returns> internal QueryOperationResponse<TElement> ProcessResult<TElement>(ProjectionPlan plan) { Debug.Assert(this.responseInfo != null, "The request didn't complete yet, we don't have a response info for it."); MaterializeAtom materializeAtom = this.CreateMaterializer(plan, this.ServiceRequest.PayloadKind); return this.GetResponse<TElement>(materializeAtom); }
internal LoadPropertyResult(object entity, string propertyName, DataServiceContext context, ODataRequestMessageWrapper request, AsyncCallback callback, object state, DataServiceRequest dataServiceRequest, ProjectionPlan plan) : base(context, "LoadProperty", dataServiceRequest, request, new RequestInfo(context), callback, state) { this.entity = entity; this.propertyName = propertyName; this.plan = plan; }
internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan) : base(nextLinkUri, plan) { }
internal static MaterializeAtom Materialize(DataServiceContext context, QueryComponents queryComponents, ProjectionPlan plan, string contentType, Stream response) { Debug.Assert(null != queryComponents, "querycomponents"); string mime = null; Encoding encoding = null; if (!String.IsNullOrEmpty(contentType)) { HttpProcessUtility.ReadContentType(contentType, out mime, out encoding); } if (String.Equals(mime, XmlConstants.MimeApplicationAtom, StringComparison.OrdinalIgnoreCase) || String.Equals(mime, XmlConstants.MimeApplicationXml, StringComparison.OrdinalIgnoreCase)) { if (null != response) { XmlReader reader = XmlUtil.CreateXmlReader(response, encoding); return new MaterializeAtom(context, reader, queryComponents, plan, context.MergeOption); } } return MaterializeAtom.EmptyResults; }
public static ODataMaterializer CreateMaterializerForMessage(IODataResponseMessage responseMessage, System.Data.Services.Client.ResponseInfo responseInfo, Type materializerType, QueryComponents queryComponents, ProjectionPlan plan, ODataPayloadKind payloadKind) { ODataMaterializer materializer2; bool projectionQuery = (plan != null) || (queryComponents.Projection != null); ODataMessageReader messageReader = CreateODataMessageReader(responseMessage, responseInfo, projectionQuery, ref payloadKind); IEdmType expectedType = null; try { ODataMaterializer materializer; if (materializerType != typeof(object)) { expectedType = ClientEdmModel.GetModel(responseInfo.MaxProtocolVersion).GetOrCreateEdmType(materializerType); } if ((payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed)) { if ((expectedType != null) && (expectedType.TypeKind != EdmTypeKind.Entity)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidNonEntityType(materializerType.FullName)); } ODataReader reader = CreateODataReader(messageReader, payloadKind, expectedType, responseInfo.MaxProtocolVersion); materializer = new ODataReaderEntityMaterializer(messageReader, reader, responseInfo, queryComponents, materializerType, plan); } else { switch (payloadKind) { case ODataPayloadKind.Property: if ((expectedType != null) && (expectedType.TypeKind == EdmTypeKind.Entity)) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidEntityType(materializerType.FullName)); } break; case ODataPayloadKind.EntityReferenceLink: case ODataPayloadKind.EntityReferenceLinks: materializer = new ODataLinksMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); goto Label_013A; case ODataPayloadKind.Value: materializer = new ODataValueMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); goto Label_013A; case ODataPayloadKind.BinaryValue: case ODataPayloadKind.Collection: case ODataPayloadKind.ServiceDocument: case ODataPayloadKind.MetadataDocument: goto Label_0129; case ODataPayloadKind.Error: { ODataError error = messageReader.ReadError(); throw new ODataErrorException(error.Message, error); } default: goto Label_0129; } materializer = new ODataPropertyMaterializer(messageReader, responseInfo, materializerType, queryComponents.SingleResult); } goto Label_013A; Label_0129: throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.AtomMaterializer_InvalidResponsePayload(responseInfo.DataNamespace)); Label_013A: materializer2 = materializer; } catch (Exception exception) { if (CommonUtil.IsCatchableExceptionType(exception)) { messageReader.Dispose(); } throw; } return materializer2; }
internal QueryOperationResponse <TElement> ProcessResult <TElement>(DataServiceContext context, ProjectionPlan plan) { MaterializeAtom materializeAtom = DataServiceRequest.Materialize(context, this.ServiceRequest.QueryComponents, plan, this.ContentType, this.GetResponseStream()); return(this.GetResponse <TElement>(materializeAtom)); }
public ODataReaderEntityMaterializer(ODataMessageReader odataMessageReader, ODataReader reader, ResponseInfo responseInfo, QueryComponents queryComponents, Type expectedType, ProjectionPlan materializeEntryPlan) : base(responseInfo, queryComponents, expectedType, materializeEntryPlan) { this.messageReader = odataMessageReader; this.itemReader = new ODataFeedOrEntryReader(reader, responseInfo); }
internal static MaterializeAtom Materialize(ResponseInfo responseInfo, System.Data.Services.Client.QueryComponents queryComponents, ProjectionPlan plan, string contentType, IODataResponseMessage message, ODataPayloadKind expectedPayloadKind) { if ((message.StatusCode != 0xcc) && !string.IsNullOrEmpty(contentType)) { return(new MaterializeAtom(responseInfo, queryComponents, plan, message, expectedPayloadKind)); } return(MaterializeAtom.EmptyResults); }
internal DataServiceRequest(System.Data.Services.Client.QueryComponents queryComponents, ProjectionPlan plan) { this.queryComponents = queryComponents; this.requestUri = queryComponents.Uri; this.plan = plan; }