/// <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);
}
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);
}
#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();
}
internal DataServiceQueryContinuation(Uri nextLinkUri, ProjectionPlan plan)
{
this.nextLinkUri = nextLinkUri;
this.plan = plan;
}
/// <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;
}
