/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task which returns an enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.ReadingResponse, "Payload kind detection is only supported in responses."); // prevent the buffering JSON reader from detecting in-stream errors - we read the error ourselves this.JsonReader.DisableInStreamErrorDetection = true; return(this.ReadPayloadStartAsync( ODataPayloadKind.Unsupported, /*propertyAndAnnotationCollector*/ null, /*isReadingNestedPayload*/ false, /*allowEmptyPayload*/ false) .FollowOnSuccessWith(t => { return this.DetectPayloadKindImplementation(detectionInfo); }) .FollowOnFaultAndCatchExceptionWith <IEnumerable <ODataPayloadKind>, ODataException>(t => { // If we are not able to read the payload in the expected JSON format/structure // return no detected payload kind below. return Enumerable.Empty <ODataPayloadKind>(); }) .FollowAlwaysWith(t => { this.JsonReader.DisableInStreamErrorDetection = false; })); }
/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task which returns an enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal Task<IEnumerable<ODataPayloadKind>> DetectPayloadKindAsync(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.ReadingResponse, "Payload kind detection is only supported in responses."); // prevent the buffering JSON reader from detecting in-stream errors - we read the error ourselves this.JsonReader.DisableInStreamErrorDetection = true; return this.ReadPayloadStartAsync( ODataPayloadKind.Unsupported, /*duplicatePropertyNamesChecker*/null, /*isReadingNestedPayload*/false, /*allowEmptyPayload*/false) .FollowOnSuccessWith(t => { return this.DetectPayloadKindImplementation(detectionInfo); }) .FollowOnFaultAndCatchExceptionWith<IEnumerable<ODataPayloadKind>, ODataException>(t => { // If we are not able to read the payload in the expected JSON format/structure // return no detected payload kind below. return Enumerable.Empty<ODataPayloadKind>(); }) .FollowAlwaysWith(t => { this.JsonReader.DisableInStreamErrorDetection = false; }); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="message">The message being read.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindImplementationAsync( Stream messageStream, ODataMessage message, bool readingResponse, ODataPayloadKindDetectionInfo detectionInfo) { ODataJsonLightInputContext jsonLightInputContext = new ODataJsonLightInputContext( this, messageStream, detectionInfo.ContentType, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, ODataVersion.V4, // NOTE: we don't rely on the version for payload kind detection; taking the latest. readingResponse, /*synchronous*/ false, detectionInfo.Model, /*urlResolver*/ null, /*payloadKindDetectionState*/ null); return(jsonLightInputContext.DetectPayloadKindAsync(detectionInfo) .FollowAlwaysWith(t => { jsonLightInputContext.Dispose(); })); }
/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal IEnumerable<ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.ReadingResponse, "Payload kind detection is only supported in responses."); // prevent the buffering JSON reader from detecting in-stream errors - we read the error ourselves this.JsonReader.DisableInStreamErrorDetection = true; try { this.ReadPayloadStart( ODataPayloadKind.Unsupported, /*duplicatePropertyNamesChecker*/null, /*isReadingNestedPayload*/false, /*allowEmptyPayload*/false); return this.DetectPayloadKindImplementation(detectionInfo); } catch (ODataException) { // If we are not able to read the payload in the expected JSON format/structure // return no detected payload kind below. return Enumerable.Empty<ODataPayloadKind>(); } finally { this.JsonReader.DisableInStreamErrorDetection = false; } }
/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.ReadingResponse, "Payload kind detection is only supported in responses."); // prevent the buffering JSON reader from detecting in-stream errors - we read the error ourselves this.JsonReader.DisableInStreamErrorDetection = true; try { this.ReadPayloadStart( ODataPayloadKind.Unsupported, /*propertyAndAnnotationCollector*/ null, /*isReadingNestedPayload*/ false, /*allowEmptyPayload*/ false); return(this.DetectPayloadKindImplementation(detectionInfo)); } catch (ODataException) { // If we are not able to read the payload in the expected JSON format/structure // return no detected payload kind below. return(Enumerable.Empty <ODataPayloadKind>()); } finally { this.JsonReader.DisableInStreamErrorDetection = false; } }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); ODataAtomPayloadKindDetectionDeserializer payloadKindDetectionDeserializer = new ODataAtomPayloadKindDetectionDeserializer(this); return(payloadKindDetectionDeserializer.DetectPayloadKind(detectionInfo)); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task which returns an enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> public Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); this.VerifyCanDetectPayloadKind(); ODataJsonLightPayloadKindDetectionDeserializer payloadKindDetectionDeserializer = new ODataJsonLightPayloadKindDetectionDeserializer(this); return(payloadKindDetectionDeserializer.DetectPayloadKindAsync(detectionInfo)); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task which returns an enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync(ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); Debug.Assert(detectionInfo != null, "detectionInfo != null"); this.VerifyCanDetectPayloadKind(); ODataJsonLightPayloadKindDetectionDeserializer payloadKindDetectionDeserializer = new ODataJsonLightPayloadKindDetectionDeserializer(this); return(payloadKindDetectionDeserializer.DetectPayloadKindAsync(detectionInfo)); }
/// <summary> /// Detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="requestMessage">The request message with the payload stream.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns> internal override IEnumerable<ODataPayloadKind> DetectPayloadKind( IODataRequestMessage requestMessage, ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); ExceptionUtils.CheckArgumentNotNull(requestMessage, "requestMessage"); ExceptionUtils.CheckArgumentNotNull(detectionInfo, "detectionInfo"); Stream messageStream = ((ODataMessage)requestMessage).GetStream(); return this.DetectPayloadKindImplementation(messageStream, /*readingResponse*/ false, /*synchronous*/ true, detectionInfo); }
/// <summary> /// Detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="requestMessage">The request message with the payload stream.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns> internal override IEnumerable <ODataPayloadKind> DetectPayloadKind( IODataRequestMessage requestMessage, ODataPayloadKindDetectionInfo detectionInfo) { ExceptionUtils.CheckArgumentNotNull(requestMessage, "requestMessage"); ExceptionUtils.CheckArgumentNotNull(detectionInfo, "detectionInfo"); Stream messageStream = ((ODataMessage)requestMessage).GetStream(); return(this.DetectPayloadKindImplementation(messageStream, /*readingResponse*/ false, /*synchronous*/ true, detectionInfo)); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="settings">Configuration settings of the OData reader.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private static IEnumerable <ODataPayloadKind> DetectPayloadKindImplementation( ODataMessageInfo messageInfo, ODataMessageReaderSettings settings) { var detectionInfo = new ODataPayloadKindDetectionInfo(messageInfo, settings); messageInfo.Encoding = detectionInfo.GetEncoding(); using (var jsonLightInputContext = new ODataJsonLightInputContext(messageInfo, settings)) { return(jsonLightInputContext.DetectPayloadKind(detectionInfo)); } }
/// <summary> /// Asynchronously detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="requestMessage">The request message with the payload stream.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task that when completed returns the set of <see cref="ODataPayloadKind"/>s /// that are supported with the specified payload.</returns> internal override Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync( IODataRequestMessageAsync requestMessage, ODataPayloadKindDetectionInfo detectionInfo) { ExceptionUtils.CheckArgumentNotNull(requestMessage, "requestMessage"); ExceptionUtils.CheckArgumentNotNull(detectionInfo, "detectionInfo"); // NOTE: After getting the message stream we already (asynchronously) buffered the whole stream in memory (in the AsyncBufferedStream). // Until we get Task-based async stream APIs and retire the AsyncBufferedStream, we call the synchronous method on the buffered stream. return(((ODataMessage)requestMessage).GetStreamAsync() .FollowOnSuccessWith(streamTask => this.DetectPayloadKindImplementation(streamTask.Result, /*readingResponse*/ false, /*synchronous*/ false, detectionInfo))); }
/// <summary> /// Detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="requestMessage">The request message with the payload stream.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>The set of <see cref="ODataPayloadKind"/>s that are supported with the specified payload.</returns> internal override IEnumerable <ODataPayloadKind> DetectPayloadKind( IODataRequestMessage requestMessage, ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); ExceptionUtils.CheckArgumentNotNull(requestMessage, "requestMessage"); ExceptionUtils.CheckArgumentNotNull(detectionInfo, "detectionInfo"); ODataMessage message = (ODataMessage)requestMessage; Stream messageStream = message.GetStream(); return(this.DetectPayloadKindImplementation(messageStream, message, /*readingResponse*/ false, detectionInfo)); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageInfo">The context information for the message.</param> /// <param name="settings">Configuration settings of the OData reader.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private static Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindImplementationAsync( ODataMessageInfo messageInfo, ODataMessageReaderSettings settings) { var detectionInfo = new ODataPayloadKindDetectionInfo(messageInfo, settings); messageInfo.Encoding = detectionInfo.GetEncoding(); var jsonLightInputContext = new ODataJsonLightInputContext(messageInfo, settings); return(jsonLightInputContext.DetectPayloadKindAsync(detectionInfo) .FollowAlwaysWith(t => { jsonLightInputContext.Dispose(); })); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private IEnumerable <ODataPayloadKind> DetectPayloadKindImplementation( Stream messageStream, bool readingResponse, ODataPayloadKindDetectionInfo detectionInfo) { using (ODataJsonLightInputContext jsonLightInputContext = new ODataJsonLightInputContext( this, messageStream, detectionInfo.ContentType, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, readingResponse, /*synchronous*/ true, detectionInfo.Model, /*urlResolver*/ null)) { return(jsonLightInputContext.DetectPayloadKind(detectionInfo)); } }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="synchronous">true if the input should be read synchronously; false if it should be read asynchronously.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private IEnumerable <ODataPayloadKind> DetectPayloadKindImplementation( Stream messageStream, bool readingResponse, bool synchronous, ODataPayloadKindDetectionInfo detectionInfo) { using (ODataJsonInputContext jsonInputContext = new ODataJsonInputContext( this, messageStream, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, ODataVersion.V3, // NOTE: we don't rely on the version for payload kind detection; taking the latest. readingResponse, synchronous, detectionInfo.Model, /*urlResolver*/ null)) { return(jsonInputContext.DetectPayloadKind()); } }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindImplementationAsync( Stream messageStream, bool readingResponse, ODataPayloadKindDetectionInfo detectionInfo) { ODataJsonLightInputContext jsonLightInputContext = new ODataJsonLightInputContext( this, messageStream, detectionInfo.ContentType, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, readingResponse, /*synchronous*/ false, detectionInfo.Model, /*urlResolver*/ null); return(jsonLightInputContext.DetectPayloadKindAsync(detectionInfo) .FollowAlwaysWith(t => { jsonLightInputContext.Dispose(); })); }
private ODataJsonLightInputContext CreateJsonLightInputContext( string payload, IEdmModel model, bool isAsync = false, bool isResponse = true) { this.messageInfo = new ODataMessageInfo { IsResponse = isResponse, MediaType = new ODataMediaType("application", "json", new KeyValuePair <string, string>("odata.streaming", "true")), IsAsync = isAsync, Model = this.model, }; this.messageReaderSettings = new ODataMessageReaderSettings(); messageReaderSettings.ShouldIncludeAnnotation = ODataUtils.CreateAnnotationFilter("*"); payloadKindDetectionInfo = new ODataPayloadKindDetectionInfo(this.messageInfo, this.messageReaderSettings); return(new ODataJsonLightInputContext( new StringReader(payload), messageInfo, messageReaderSettings)); }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> /// <remarks>This method decides the payload kind based on the fully-qualified element name of the top-level Xml element /// in the payload for entry, feed, entity reference link, error and service document payload kinds. It performs more checks /// for properties and collection payloads as follows: /// * If an m:type attribute is found => property /// * If an m:null attribute is found => property /// Otherwise the shape of the payload decides: /// * If we only find d:element child nodes => collection or property /// * If we find no child nodes => primitive property /// * If we find anything else => complex property /// </remarks> internal IEnumerable<ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); this.XmlReader.DisableInStreamErrorDetection = true; try { if (this.XmlReader.TryReadToNextElement()) { if (string.CompareOrdinal(AtomConstants.AtomNamespace, this.XmlReader.NamespaceURI) == 0) { // ATOM namespace for <entry> and <feed> if (string.CompareOrdinal(AtomConstants.AtomEntryElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.Entry }; } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomFeedElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.Feed }; } } else if (string.CompareOrdinal(AtomConstants.ODataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData namespace for entity reference links, properties, collections // NOTE: everything in the OData namespace is considered a property (or collection). Some of them // may have a potential other payload kind as well. // // Only check for property or collection if these payload kinds are even included in the possible payload kinds IEnumerable<ODataPayloadKind> possiblePayloadKinds = detectionInfo.PossiblePayloadKinds; IEnumerable<ODataPayloadKind> payloadKinds = possiblePayloadKinds.Contains(ODataPayloadKind.Property) || possiblePayloadKinds.Contains(ODataPayloadKind.Collection) ? this.DetectPropertyOrCollectionPayloadKind() : Enumerable.Empty<ODataPayloadKind>(); if (string.CompareOrdinal(AtomConstants.ODataUriElementName, this.XmlReader.LocalName) == 0) { payloadKinds = payloadKinds.Concat(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataLinksElementName, this.XmlReader.LocalName) == 0) { payloadKinds = payloadKinds.Concat(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLinks }); } return payloadKinds; } else if (string.CompareOrdinal(AtomConstants.ODataMetadataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData metadata namespace for errors and <m:uri> (back compat behavior instead of <d:uri>) if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataErrorElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.Error }; } if (string.CompareOrdinal(AtomConstants.ODataUriElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }; } } else if (string.CompareOrdinal(AtomConstants.AtomPublishingNamespace, this.XmlReader.NamespaceURI) == 0) { // AtomPub namespace for service doc if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomPublishingServiceElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.ServiceDocument }; } } //// If none of the above namespaces is found, we don't understand the payload in the ATOM format. } } catch (XmlException) { // If we are not able to read the payload as XML // return no detected payload kind below. } finally { this.XmlReader.DisableInStreamErrorDetection = false; } return Enumerable.Empty<ODataPayloadKind>(); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="synchronous">true if the input should be read synchronously; false if it should be read asynchronously.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> private IEnumerable<ODataPayloadKind> DetectPayloadKindImplementation( Stream messageStream, bool readingResponse, bool synchronous, ODataPayloadKindDetectionInfo detectionInfo) { using (ODataAtomInputContext inputContext = new ODataAtomInputContext( this, messageStream, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, readingResponse, synchronous, detectionInfo.Model, /*urlResolver*/ null)) { return inputContext.DetectPayloadKind(detectionInfo); } }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> internal IEnumerable<ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); ODataAtomPayloadKindDetectionDeserializer payloadKindDetectionDeserializer = new ODataAtomPayloadKindDetectionDeserializer(this); return payloadKindDetectionDeserializer.DetectPayloadKind(detectionInfo); }
internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { base.XmlReader.DisableInStreamErrorDetection = true; try { if (base.XmlReader.TryReadToNextElement()) { if (string.CompareOrdinal("http://www.w3.org/2005/Atom", base.XmlReader.NamespaceURI) == 0) { if (string.CompareOrdinal("entry", base.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Entry }); } if (base.ReadingResponse && (string.CompareOrdinal("feed", base.XmlReader.LocalName) == 0)) { return(new ODataPayloadKind[1]); } } else { if (string.CompareOrdinal("http://schemas.microsoft.com/ado/2007/08/dataservices", base.XmlReader.NamespaceURI) == 0) { IEnumerable <ODataPayloadKind> possiblePayloadKinds = detectionInfo.PossiblePayloadKinds; IEnumerable <ODataPayloadKind> first = (possiblePayloadKinds.Contains <ODataPayloadKind>(ODataPayloadKind.Property) || possiblePayloadKinds.Contains <ODataPayloadKind>(ODataPayloadKind.Collection)) ? this.DetectPropertyOrCollectionPayloadKind() : Enumerable.Empty <ODataPayloadKind>(); if (string.CompareOrdinal("uri", base.XmlReader.LocalName) == 0) { first = first.Concat <ODataPayloadKind>(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } if (base.ReadingResponse && (string.CompareOrdinal("links", base.XmlReader.LocalName) == 0)) { first = first.Concat <ODataPayloadKind>(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLinks }); } return(first); } if (string.CompareOrdinal("http://schemas.microsoft.com/ado/2007/08/dataservices/metadata", base.XmlReader.NamespaceURI) == 0) { if (base.ReadingResponse && (string.CompareOrdinal("error", base.XmlReader.LocalName) == 0)) { return(new ODataPayloadKind[] { ODataPayloadKind.Error }); } if (string.CompareOrdinal("uri", base.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } } else if (((string.CompareOrdinal("http://www.w3.org/2007/app", base.XmlReader.NamespaceURI) == 0) && base.ReadingResponse) && (string.CompareOrdinal("service", base.XmlReader.LocalName) == 0)) { return(new ODataPayloadKind[] { ODataPayloadKind.ServiceDocument }); } } } } catch (XmlException) { } finally { base.XmlReader.DisableInStreamErrorDetection = false; } return(Enumerable.Empty <ODataPayloadKind>()); }
internal override IEnumerable <ODataPayloadKind> DetectPayloadKind(IODataResponseMessage responseMessage, ODataPayloadKindDetectionInfo detectionInfo) { ExceptionUtils.CheckArgumentNotNull <IODataResponseMessage>(responseMessage, "responseMessage"); ExceptionUtils.CheckArgumentNotNull <ODataPayloadKindDetectionInfo>(detectionInfo, "detectionInfo"); Stream messageStream = ((ODataMessage)responseMessage).GetStream(); return(this.DetectPayloadKindImplementation(messageStream, true, true, detectionInfo)); }
/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private IEnumerable<ODataPayloadKind> DetectPayloadKindImplementation(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.JsonReader.DisableInStreamErrorDetection, "The in-stream error detection should be disabled for payload kind detection."); this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject); // If we found a context URI and parsed it, look at the detected payload kind and return it. if (this.ContextUriParseResult != null) { return this.ContextUriParseResult.DetectedPayloadKinds; } // Otherwise this is a payload without context URI and we have to start sniffing; only error payloads // don't have a context URI so check for a single 'error' property (ignoring custom annotations). ODataError error = null; while (this.JsonReader.NodeType == JsonNodeType.Property) { string propertyName = this.JsonReader.ReadPropertyName(); string annotatedPropertyName, annotationName; if (!ODataJsonLightDeserializer.TryParsePropertyAnnotation(propertyName, out annotatedPropertyName, out annotationName)) { if (ODataJsonLightReaderUtils.IsAnnotationProperty(propertyName)) { if (propertyName != null && propertyName.StartsWith(JsonLightConstants.ODataPropertyAnnotationSeparatorChar + JsonLightConstants.ODataAnnotationNamespacePrefix, System.StringComparison.Ordinal)) { // Any @odata.* instance annotations are not allowed for errors. return Enumerable.Empty<ODataPayloadKind>(); } else { // Skip custom instance annotations this.JsonReader.SkipValue(); } } else { if (string.CompareOrdinal(JsonLightConstants.ODataErrorPropertyName, propertyName) == 0) { // If we find multiple errors or an invalid error value, this is not an error payload. if (error != null || !this.JsonReader.StartBufferingAndTryToReadInStreamErrorPropertyValue(out error)) { return Enumerable.Empty<ODataPayloadKind>(); } // At this point we successfully read the first error property. // Skip the error value and check whether there are more properties. this.JsonReader.SkipValue(); } else { // if it contains non-annotation property, it is not an error payload. return Enumerable.Empty<ODataPayloadKind>(); } } } else { // Property annotation return Enumerable.Empty<ODataPayloadKind>(); } } // If we got here without finding a context URI or an error payload, we don't know what this is. if (error == null) { return Enumerable.Empty<ODataPayloadKind>(); } return new ODataPayloadKind[] { ODataPayloadKind.Error }; }
/// <summary> /// Detects the payload kind(s). /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private IEnumerable <ODataPayloadKind> DetectPayloadKindImplementation(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); Debug.Assert(this.JsonReader.DisableInStreamErrorDetection, "The in-stream error detection should be disabled for payload kind detection."); this.AssertJsonCondition(JsonNodeType.Property, JsonNodeType.EndObject); // If we found a context URI and parsed it, look at the detected payload kind and return it. if (this.ContextUriParseResult != null) { return(this.ContextUriParseResult.DetectedPayloadKinds); } // Otherwise this is a payload without context URI and we have to start sniffing; only error payloads // don't have a context URI so check for a single 'error' property (ignoring custom annotations). ODataError error = null; while (this.JsonReader.NodeType == JsonNodeType.Property) { string propertyName = this.JsonReader.ReadPropertyName(); string annotatedPropertyName, annotationName; if (!ODataJsonLightDeserializer.TryParsePropertyAnnotation(propertyName, out annotatedPropertyName, out annotationName)) { if (ODataJsonLightReaderUtils.IsAnnotationProperty(propertyName)) { if (propertyName != null && propertyName.StartsWith(JsonLightConstants.ODataPropertyAnnotationSeparatorChar + JsonLightConstants.ODataAnnotationNamespacePrefix, System.StringComparison.Ordinal)) { // Any @odata.* instance annotations are not allowed for errors. return(Enumerable.Empty <ODataPayloadKind>()); } else { // Skip custom instance annotations this.JsonReader.SkipValue(); } } else { if (string.CompareOrdinal(JsonLightConstants.ODataErrorPropertyName, propertyName) == 0) { // If we find multiple errors or an invalid error value, this is not an error payload. if (error != null || !this.JsonReader.StartBufferingAndTryToReadInStreamErrorPropertyValue(out error)) { return(Enumerable.Empty <ODataPayloadKind>()); } // At this point we successfully read the first error property. // Skip the error value and check whether there are more properties. this.JsonReader.SkipValue(); } else { // if it contains non-annotation property, it is not an error payload. return(Enumerable.Empty <ODataPayloadKind>()); } } } else { // Property annotation return(Enumerable.Empty <ODataPayloadKind>()); } } // If we got here without finding a context URI or an error payload, we don't know what this is. if (error == null) { return(Enumerable.Empty <ODataPayloadKind>()); } return(new ODataPayloadKind[] { ODataPayloadKind.Error }); }
internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { ODataAtomPayloadKindDetectionDeserializer deserializer = new ODataAtomPayloadKindDetectionDeserializer(this); return(deserializer.DetectPayloadKind(detectionInfo)); }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> /// <remarks>This method decides the payload kind based on the fully-qualified element name of the top-level Xml element /// in the payload for entry, feed, entity reference link, error and service document payload kinds. It performs more checks /// for properties and collection payloads as follows: /// * If an m:type attribute is found => property /// * If an m:null attribute is found => property /// Otherwise the shape of the payload decides: /// * If we only find m:element child nodes => collection or property /// * If we find no child nodes => primitive property /// * If we find anything else => complex property /// </remarks> internal IEnumerable<ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { this.XmlReader.DisableInStreamErrorDetection = true; try { if (this.XmlReader.TryReadToNextElement()) { if (string.CompareOrdinal(AtomConstants.AtomNamespace, this.XmlReader.NamespaceURI) == 0) { // ATOM namespace for <entry> and <feed> if (string.CompareOrdinal(AtomConstants.AtomEntryElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.Entry }; } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomFeedElementName, this.XmlReader.LocalName) == 0) { if (this.XmlReader.XmlBaseUri != null && this.XmlReader.XmlBaseUri.AbsoluteUri.Contains(ODataConstants.EntityReferenceSegmentName)) { return new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLinks }; } else { return new ODataPayloadKind[] { ODataPayloadKind.Feed }; } } } else if (string.CompareOrdinal(AtomConstants.ODataNamespace, this.XmlReader.NamespaceURI) == 0) { // Will figure out whether we need to remove this part of logic, since in the top level, the format has been changed to <m:value // OData namespace for entity reference links, properties, collections // NOTE: everything in the OData namespace is considered a property (or collection). Some of them // may have a potential other payload kind as well. return this.DetectPropertyOrCollectionPayloadKind(); } else if (string.CompareOrdinal(AtomConstants.ODataMetadataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData metadata namespace for collections // Only check for property or collection if these payload kinds are even included in the possible payload kinds if (string.CompareOrdinal(AtomConstants.ODataValueElementName, this.XmlReader.LocalName) == 0) { return this.DetectPropertyOrCollectionPayloadKind(); } // OData metadata namespace for errors and <m:ref> if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataErrorElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.Error }; } if (string.CompareOrdinal(AtomConstants.ODataRefElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }; } } else if (string.CompareOrdinal(AtomConstants.AtomPublishingNamespace, this.XmlReader.NamespaceURI) == 0) { // AtomPub namespace for service doc if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomPublishingServiceElementName, this.XmlReader.LocalName) == 0) { return new ODataPayloadKind[] { ODataPayloadKind.ServiceDocument }; } } //// If none of the above namespaces is found, we don't understand the payload in the ATOM format. } } catch (XmlException) { // If we are not able to read the payload as XML // return no detected payload kind below. } finally { this.XmlReader.DisableInStreamErrorDetection = false; } return Enumerable.Empty<ODataPayloadKind>(); }
internal override Task <IEnumerable <ODataPayloadKind> > DetectPayloadKindAsync(IODataResponseMessageAsync responseMessage, ODataPayloadKindDetectionInfo detectionInfo) { ExceptionUtils.CheckArgumentNotNull <IODataResponseMessageAsync>(responseMessage, "responseMessage"); ExceptionUtils.CheckArgumentNotNull <ODataPayloadKindDetectionInfo>(detectionInfo, "detectionInfo"); return(((ODataMessage)responseMessage).GetStreamAsync().FollowOnSuccessWith <Stream, IEnumerable <ODataPayloadKind> >(streamTask => this.DetectPayloadKindImplementation(streamTask.Result, true, false, detectionInfo))); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task which returns an enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> internal Task<IEnumerable<ODataPayloadKind>> DetectPayloadKindAsync(ODataPayloadKindDetectionInfo detectionInfo) { Debug.Assert(detectionInfo != null, "detectionInfo != null"); this.VerifyCanDetectPayloadKind(); ODataJsonLightPayloadKindDetectionDeserializer payloadKindDetectionDeserializer = new ODataJsonLightPayloadKindDetectionDeserializer(this); return payloadKindDetectionDeserializer.DetectPayloadKindAsync(detectionInfo); }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> /// <remarks>This method decides the payload kind based on the fully-qualified element name of the top-level Xml element /// in the payload for entry, feed, entity reference link, error and service document payload kinds. It performs more checks /// for properties and collection payloads as follows: /// * If an m:type attribute is found => property /// * If an m:null attribute is found => property /// Otherwise the shape of the payload decides: /// * If we only find d:element child nodes => collection or property /// * If we find no child nodes => primitive property /// * If we find anything else => complex property /// </remarks> internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); this.XmlReader.DisableInStreamErrorDetection = true; try { if (this.XmlReader.TryReadToNextElement()) { if (string.CompareOrdinal(AtomConstants.AtomNamespace, this.XmlReader.NamespaceURI) == 0) { // ATOM namespace for <entry> and <feed> if (string.CompareOrdinal(AtomConstants.AtomEntryElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Entry }); } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomFeedElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Feed }); } } else if (string.CompareOrdinal(AtomConstants.ODataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData namespace for entity reference links, properties, collections // NOTE: everything in the OData namespace is considered a property (or collection). Some of them // may have a potential other payload kind as well. // // Only check for property or collection if these payload kinds are even included in the possible payload kinds IEnumerable <ODataPayloadKind> possiblePayloadKinds = detectionInfo.PossiblePayloadKinds; IEnumerable <ODataPayloadKind> payloadKinds = possiblePayloadKinds.Any(k => k == ODataPayloadKind.Property || k == ODataPayloadKind.Collection) ? this.DetectPropertyOrCollectionPayloadKind() : Enumerable.Empty <ODataPayloadKind>(); if (string.CompareOrdinal(AtomConstants.ODataUriElementName, this.XmlReader.LocalName) == 0) { payloadKinds = payloadKinds.Concat(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataLinksElementName, this.XmlReader.LocalName) == 0) { payloadKinds = payloadKinds.Concat(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLinks }); } return(payloadKinds); } else if (string.CompareOrdinal(AtomConstants.ODataMetadataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData metadata namespace for errors and <m:uri> (back compat behavior instead of <d:uri>) if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataErrorElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Error }); } if (string.CompareOrdinal(AtomConstants.ODataUriElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } } else if (string.CompareOrdinal(AtomConstants.AtomPublishingNamespace, this.XmlReader.NamespaceURI) == 0) { // AtomPub namespace for service doc if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomPublishingServiceElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.ServiceDocument }); } } //// If none of the above namespaces is found, we don't understand the payload in the ATOM format. } } catch (XmlException) { // If we are not able to read the payload as XML // return no detected payload kind below. } finally { this.XmlReader.DisableInStreamErrorDetection = false; } return(Enumerable.Empty <ODataPayloadKind>()); }
private IEnumerable <ODataPayloadKind> DetectPayloadKindImplementation(Stream messageStream, bool readingResponse, bool synchronous, ODataPayloadKindDetectionInfo detectionInfo) { using (ODataAtomInputContext context = new ODataAtomInputContext(this, messageStream, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, ODataVersion.V3, readingResponse, synchronous, detectionInfo.Model, null)) { return(context.DetectPayloadKind(detectionInfo)); } }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="synchronous">true if the input should be read synchronously; false if it should be read asynchronously.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> private IEnumerable<ODataPayloadKind> DetectPayloadKindImplementation( Stream messageStream, bool readingResponse, bool synchronous, ODataPayloadKindDetectionInfo detectionInfo) { using (ODataAtomInputContext inputContext = new ODataAtomInputContext( this, messageStream, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, ODataVersion.V3, // NOTE: we don't rely on the version for payload kind detection; taking the latest. readingResponse, synchronous, detectionInfo.Model, /*urlResolver*/ null)) { return inputContext.DetectPayloadKind(detectionInfo); } }
/// <summary> /// Detects the payload kind(s) of the payload. /// </summary> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero or more payload kinds depending on what payload kinds were detected.</returns> /// <remarks>This method decides the payload kind based on the fully-qualified element name of the top-level Xml element /// in the payload for entry, feed, entity reference link, error and service document payload kinds. It performs more checks /// for properties and collection payloads as follows: /// * If an m:type attribute is found => property /// * If an m:null attribute is found => property /// Otherwise the shape of the payload decides: /// * If we only find m:element child nodes => collection or property /// * If we find no child nodes => primitive property /// * If we find anything else => complex property /// </remarks> internal IEnumerable <ODataPayloadKind> DetectPayloadKind(ODataPayloadKindDetectionInfo detectionInfo) { this.XmlReader.DisableInStreamErrorDetection = true; try { if (this.XmlReader.TryReadToNextElement()) { if (string.CompareOrdinal(AtomConstants.AtomNamespace, this.XmlReader.NamespaceURI) == 0) { // ATOM namespace for <entry> and <feed> if (string.CompareOrdinal(AtomConstants.AtomEntryElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Entry }); } if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomFeedElementName, this.XmlReader.LocalName) == 0) { if (this.XmlReader.XmlBaseUri != null && this.XmlReader.XmlBaseUri.AbsoluteUri.Contains(ODataConstants.EntityReferenceSegmentName)) { return(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLinks }); } else { return(new ODataPayloadKind[] { ODataPayloadKind.Feed }); } } } else if (string.CompareOrdinal(AtomConstants.ODataNamespace, this.XmlReader.NamespaceURI) == 0) { // Will figure out whether we need to remove this part of logic, since in the top level, the format has been changed to <m:value // OData namespace for entity reference links, properties, collections // NOTE: everything in the OData namespace is considered a property (or collection). Some of them // may have a potential other payload kind as well. // // Only check for property or collection if these payload kinds are even included in the possible payload kinds IEnumerable <ODataPayloadKind> possiblePayloadKinds = detectionInfo.PossiblePayloadKinds; IEnumerable <ODataPayloadKind> payloadKinds = possiblePayloadKinds.Any(k => k == ODataPayloadKind.Property || k == ODataPayloadKind.Collection) ? this.DetectPropertyOrCollectionPayloadKind() : Enumerable.Empty <ODataPayloadKind>(); return(payloadKinds); } else if (string.CompareOrdinal(AtomConstants.ODataMetadataNamespace, this.XmlReader.NamespaceURI) == 0) { // OData metadata namespace for collections // Only check for property or collection if these payload kinds are even included in the possible payload kinds if (string.CompareOrdinal(AtomConstants.ODataValueElementName, this.XmlReader.LocalName) == 0) { IEnumerable <ODataPayloadKind> possiblePayloadKinds = detectionInfo.PossiblePayloadKinds; IEnumerable <ODataPayloadKind> payloadKinds = possiblePayloadKinds.Any(k => k == ODataPayloadKind.Property || k == ODataPayloadKind.Collection) ? this.DetectPropertyOrCollectionPayloadKind() : Enumerable.Empty <ODataPayloadKind>(); return(payloadKinds); } // OData metadata namespace for errors and <m:ref> if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.ODataErrorElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.Error }); } if (string.CompareOrdinal(AtomConstants.ODataRefElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.EntityReferenceLink }); } } else if (string.CompareOrdinal(AtomConstants.AtomPublishingNamespace, this.XmlReader.NamespaceURI) == 0) { // AtomPub namespace for service doc if (this.ReadingResponse && string.CompareOrdinal(AtomConstants.AtomPublishingServiceElementName, this.XmlReader.LocalName) == 0) { return(new ODataPayloadKind[] { ODataPayloadKind.ServiceDocument }); } } //// If none of the above namespaces is found, we don't understand the payload in the ATOM format. } } catch (XmlException) { // If we are not able to read the payload as XML // return no detected payload kind below. } finally { this.XmlReader.DisableInStreamErrorDetection = false; } return(Enumerable.Empty <ODataPayloadKind>()); }
/// <summary> /// Asynchronously detects the payload kinds supported by this format for the specified message payload. /// </summary> /// <param name="responseMessage">The response message with the payload stream.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>A task that when completed returns the set of <see cref="ODataPayloadKind"/>s /// that are supported with the specified payload.</returns> internal override Task<IEnumerable<ODataPayloadKind>> DetectPayloadKindAsync( IODataResponseMessageAsync responseMessage, ODataPayloadKindDetectionInfo detectionInfo) { DebugUtils.CheckNoExternalCallers(); ExceptionUtils.CheckArgumentNotNull(responseMessage, "responseMessage"); ExceptionUtils.CheckArgumentNotNull(detectionInfo, "detectionInfo"); // NOTE: After getting the message stream we already (asynchronously) buffered the whole stream in memory (in the AsyncBufferedStream). // Until we get Task-based async stream APIs and retire the AsyncBufferedStream, we call the synchronous method on the buffered stream. return ((ODataMessage)responseMessage).GetStreamAsync() .FollowOnSuccessWith(streamTask => this.DetectPayloadKindImplementation(streamTask.Result, /*readingResponse*/ true, /*synchronous*/ false, detectionInfo)); }
/// <summary> /// Detects the payload kind(s) from the message stream. /// </summary> /// <param name="messageStream">The message stream to read from for payload kind detection.</param> /// <param name="readingResponse">true if reading a response message; otherwise false.</param> /// <param name="detectionInfo">Additional information available for the payload kind detection.</param> /// <returns>An enumerable of zero, one or more payload kinds that were detected from looking at the payload in the message stream.</returns> private Task<IEnumerable<ODataPayloadKind>> DetectPayloadKindImplementationAsync( Stream messageStream, bool readingResponse, ODataPayloadKindDetectionInfo detectionInfo) { ODataJsonLightInputContext jsonLightInputContext = new ODataJsonLightInputContext( this, messageStream, detectionInfo.ContentType, detectionInfo.GetEncoding(), detectionInfo.MessageReaderSettings, readingResponse, /*synchronous*/ false, detectionInfo.Model, /*urlResolver*/ null); return jsonLightInputContext.DetectPayloadKindAsync(detectionInfo) .FollowAlwaysWith(t => { jsonLightInputContext.Dispose(); }); }