private void ProcessContentType(params ODataPayloadKind[] payloadKinds)
{
MediaType type;
string contentTypeHeader = this.GetContentTypeHeader();
this.format = MediaTypeUtils.GetFormatFromContentType(contentTypeHeader, payloadKinds, this.MediaTypeResolver, out type, out this.encoding, out this.readerPayloadKind, out this.batchBoundary);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
internal ODataMetadataOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageStream != null, "messageStream != null");
Debug.Assert(synchronous, "Metadata output context is only supported in synchronous operations.");
try
{
this.messageOutputStream = messageStream;
this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the output context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Create a metadata input context.
/// </summary>
/// <param name="format">The format for this input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Stream messageStream = message.GetStream();
return(new ODataMetadataInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver));
}
/// <summary>Initializes a new instance of the <see cref="T:Microsoft.Data.OData.ODataMessageWriterSettings" /> class with specified settings.</summary>
/// <param name="other">The specified settings.</param>
public ODataMessageWriterSettings(ODataMessageWriterSettings other)
: base(other)
{
ExceptionUtils.CheckArgumentNotNull(other, "other");
this.acceptCharSets = other.acceptCharSets;
this.acceptMediaTypes = other.acceptMediaTypes;
this.BaseUri = other.BaseUri;
this.DisableMessageStreamDisposal = other.DisableMessageStreamDisposal;
this.format = other.format;
this.useFormat = other.useFormat;
this.Version = other.Version;
this.metadataDocumentUri = other.metadataDocumentUri;
this.atomFormatStartEntryXmlCustomizationCallback = other.atomFormatStartEntryXmlCustomizationCallback;
this.atomFormatEndEntryXmlCustomizationCallback = other.atomFormatEndEntryXmlCustomizationCallback;
this.JsonPCallback = other.JsonPCallback;
this.shouldIncludeAnnotation = other.shouldIncludeAnnotation;
this.AutoComputePayloadMetadataInJson = other.AutoComputePayloadMetadataInJson;
this.AutoGeneratedUrlsShouldPutKeyValueInDedicatedSegment = other.AutoGeneratedUrlsShouldPutKeyValueInDedicatedSegment;
this.alwaysUseDefaultXmlNamespaceForRootElement = other.alwaysUseDefaultXmlNamespaceForRootElement;
this.UndeclaredPropertyBehaviorKinds = other.UndeclaredPropertyBehaviorKinds;
// NOTE: writer behavior is immutable; copy by reference is ok.
this.writerBehavior = other.writerBehavior;
}
public void SetContentType(ODataFormat payloadFormat)
{
this.acceptCharSets = null;
this.acceptMediaTypes = null;
this.format = payloadFormat;
this.useFormat = true;
}
/// <summary>
/// Create metadata output context.
/// </summary>
/// <param name="format">The format to create the output context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>The newly created output context.</returns>
internal static ODataOutputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.Metadata, "This method only supports the Metadata format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageWriterSettings != null, "messageWriterSettings != null");
Stream messageStream = message.GetStream();
return(new ODataMetadataOutputContext(
format,
messageStream,
encoding,
messageWriterSettings,
writingResponse,
true,
model,
urlResolver));
}
private ODataAtomOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
Stream asynchronousOutputStream;
this.messageOutputStream = messageStream;
if (synchronous)
{
asynchronousOutputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
asynchronousOutputStream = this.asynchronousOutputStream;
}
this.xmlRootWriter = ODataAtomWriterUtils.CreateXmlWriter(asynchronousOutputStream, messageWriterSettings, encoding);
this.xmlWriter = this.xmlRootWriter;
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
internal static ODataFormat GetFormatFromContentType(string contentTypeHeader, ODataPayloadKind[] supportedPayloadKinds, MediaTypeResolver mediaTypeResolver, out MediaType mediaType, out Encoding encoding, out ODataPayloadKind selectedPayloadKind, out string batchBoundary)
{
ODataFormat format = GetFormatFromContentType(contentTypeHeader, supportedPayloadKinds, mediaTypeResolver, out mediaType, out encoding, out selectedPayloadKind);
if (selectedPayloadKind == ODataPayloadKind.Batch)
{
KeyValuePair <string, string> pair = new KeyValuePair <string, string>();
IEnumerable <KeyValuePair <string, string> > parameters = mediaType.Parameters;
if (parameters != null)
{
bool flag = false;
foreach (KeyValuePair <string, string> pair2 in from p in parameters
where HttpUtils.CompareMediaTypeParameterNames("boundary", p.Key)
select p)
{
if (flag)
{
throw new ODataException(Microsoft.Data.OData.Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, "boundary"));
}
pair = pair2;
flag = true;
}
}
if (pair.Key == null)
{
throw new ODataException(Microsoft.Data.OData.Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, "boundary"));
}
batchBoundary = pair.Value;
ValidationUtils.ValidateBoundaryString(batchBoundary);
return(format);
}
batchBoundary = null;
return(format);
}
public void SetContentType(string acceptableMediaTypes, string acceptableCharSets)
{
this.acceptMediaTypes = acceptableMediaTypes;
this.acceptCharSets = acceptableCharSets;
this.format = null;
this.useFormat = false;
}
/// <summary>
/// Sets the acceptable media types and character sets from which the content type will be computed when writing the payload.
/// </summary>
/// <param name="acceptableMediaTypes">
/// The acceptable media types used to determine the content type of the message.
/// This is a comma separated list of content types as specified in RFC 2616, Section 14.1
/// </param>
/// <param name="acceptableCharSets">
/// The acceptable charsets to use to the determine the encoding of the message.
/// This is a comma separated list of charsets as specified in RFC 2616, Section 14.2
/// </param>
/// <remarks>Calling this method replaces any previously set content-type settings.</remarks>
public void SetContentType(string acceptableMediaTypes, string acceptableCharSets)
{
this.acceptMediaTypes = acceptableMediaTypes;
this.acceptCharSets = acceptableCharSets;
this.format = null;
this.useFormat = false;
}
/// <summary>
/// Sets the format to be used when writing the payload. This will automatically set a compatible
/// content type header.
/// </summary>
/// <param name="payloadFormat">The format to use for writing the payload.</param>
/// <remarks>Calling this method replaces any previously set content-type settings.</remarks>
public void SetContentType(ODataFormat payloadFormat)
{
this.acceptCharSets = null;
this.acceptMediaTypes = null;
this.format = payloadFormat;
this.useFormat = true;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
private ODataRawOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.encoding = encoding;
if (synchronous)
{
this.outputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
this.outputStream = this.asynchronousOutputStream;
}
}
catch
{
messageStream.Dispose();
throw;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
private ODataMetadataOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
Debug.Assert(synchronous, "Metadata output context is only supported in synchronous operations.");
try
{
this.messageOutputStream = messageStream;
this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the output context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="format">The format for this output context.</param>
/// <param name="messageStream">The message stream to write the payload to.</param>
/// <param name="encoding">The encoding to use for the payload.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="synchronous">true if the output should be written synchronously; false if it should be written asynchronously.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
internal ODataRawOutputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageStream != null, "messageStream != null");
try
{
this.messageOutputStream = messageStream;
this.encoding = encoding;
if (synchronous)
{
this.outputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
this.outputStream = this.asynchronousOutputStream;
}
}
catch
{
messageStream.Dispose();
throw;
}
}
private ODataJsonOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
Stream asynchronousOutputStream;
this.messageOutputStream = messageStream;
if (synchronous)
{
asynchronousOutputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
asynchronousOutputStream = this.asynchronousOutputStream;
}
this.textWriter = new StreamWriter(asynchronousOutputStream, encoding);
this.jsonWriter = new Microsoft.Data.OData.Json.JsonWriter(this.textWriter, messageWriterSettings.Indent);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private static Action<Stream> CreateErrorSerializer(ODataFormat responseFormat, HandleExceptionArgs args, Encoding encoding)
{
ErrorHandler handler = new ErrorHandler(args, encoding);
if (responseFormat == ODataFormat.VerboseJson)
{
return new Action<Stream>(handler.SerializeJsonErrorToStream);
}
return new Action<Stream>(handler.SerializeXmlErrorToStream);
}
/// <summary>
/// Asynchronously creates an instance of the input context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>Task which when completed returned the newly created input context.</returns>
internal static Task <ODataInputContext> CreateInputContextAsync(
ODataFormat format,
ODataPayloadKind readerPayloadKind,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format != ODataFormat.Metadata, "Async reading of metadata documents is not supported.");
Debug.Assert(readerPayloadKind != ODataPayloadKind.MetadataDocument, "Async reading of metadata documents is not supported.");
if (format == ODataFormat.Atom)
{
return(ODataAtomInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver));
}
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return(ODataRawInputContext.CreateAsync(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver,
readerPayloadKind));
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
internal ResponseBodyWriter(bool hasMoved, IDataService service, IEnumerator queryResults, RequestDescription requestDescription, IODataResponseMessage responseMessage, ODataPayloadKind payloadKind)
{
this.hasMoved = hasMoved;
this.service = service;
this.queryResults = queryResults;
this.requestDescription = requestDescription;
this.responseMessage = responseMessage;
this.payloadKind = payloadKind;
this.encoding = HttpProcessUtility.EncodingFromAcceptCharset(this.service.OperationContext.Host.RequestAcceptCharSet);
if ((((payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed)) || ((payloadKind == ODataPayloadKind.Property) || (payloadKind == ODataPayloadKind.Collection))) || (((payloadKind == ODataPayloadKind.EntityReferenceLink) || (payloadKind == ODataPayloadKind.EntityReferenceLinks)) || (((payloadKind == ODataPayloadKind.Error) || (payloadKind == ODataPayloadKind.ServiceDocument)) || (payloadKind == ODataPayloadKind.Parameter))))
{
DataServiceHostWrapper host = service.OperationContext.Host;
if (WebUtil.GetEffectiveMaxResponseVersion(service.Configuration.DataServiceBehavior.MaxProtocolVersion, host.RequestMaxVersion) > RequestDescription.Version2Dot0)
{
bool isEntityOrFeed = (payloadKind == ODataPayloadKind.Entry) || (payloadKind == ODataPayloadKind.Feed);
if (WebUtil.ResponseMediaTypeWouldBeJsonLight(host.RequestAccept, isEntityOrFeed))
{
requestDescription.VerifyAndRaiseResponseVersion(RequestDescription.Version3Dot0, service);
host.ResponseVersion = RequestDescription.Version3Dot0.ToString() + ";";
}
}
}
if (this.requestDescription.TargetKind == RequestTargetKind.MediaResource)
{
this.mediaResourceStream = service.StreamProvider.GetReadStream(this.queryResults.Current, RequestDescription.GetStreamProperty(this.requestDescription), this.service.OperationContext);
}
else if (payloadKind != ODataPayloadKind.BinaryValue)
{
string requestAcceptCharSet = this.service.OperationContext.Host.RequestAcceptCharSet;
if (string.IsNullOrEmpty(requestAcceptCharSet) || (requestAcceptCharSet == "*"))
{
requestAcceptCharSet = "UTF-8";
}
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, ODataFormat.RawValue);
}
else
{
this.messageWriter = CreateMessageWriter(this.AbsoluteServiceUri, this.service, this.requestDescription.ActualResponseVersion, responseMessage, this.service.OperationContext.Host.RequestAccept, requestAcceptCharSet);
}
try
{
this.contentFormat = ODataUtils.SetHeadersForPayload(this.messageWriter, payloadKind);
if ((payloadKind == ODataPayloadKind.Value) && !string.IsNullOrEmpty(this.requestDescription.MimeType))
{
responseMessage.SetHeader("Content-Type", this.requestDescription.MimeType);
}
}
catch (ODataContentTypeException exception)
{
throw new DataServiceException(0x19f, null, System.Data.Services.Strings.DataServiceException_UnsupportedMediaType, null, exception);
}
string headerValue = this.requestDescription.ResponseVersion.ToString() + ";";
responseMessage.SetHeader("DataServiceVersion", headerValue);
}
}
protected ODataOutputContext(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageWriterSettings>(messageWriterSettings, "messageWriterSettings");
this.format = format;
this.messageWriterSettings = messageWriterSettings;
this.writingResponse = writingResponse;
this.synchronous = synchronous;
this.model = model;
this.urlResolver = urlResolver;
}
protected ODataOutputContext(ODataFormat format, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver)
{
ExceptionUtils.CheckArgumentNotNull <ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull <ODataMessageWriterSettings>(messageWriterSettings, "messageWriterSettings");
this.format = format;
this.messageWriterSettings = messageWriterSettings;
this.writingResponse = writingResponse;
this.synchronous = synchronous;
this.model = model;
this.urlResolver = urlResolver;
}
protected ODataInputContext(ODataFormat format, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver)
{
ExceptionUtils.CheckArgumentNotNull <ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull <ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
this.format = format;
this.messageReaderSettings = messageReaderSettings;
this.version = version;
this.readingResponse = readingResponse;
this.synchronous = synchronous;
this.model = model;
this.urlResolver = urlResolver;
}
protected ODataInputContext(ODataFormat format, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
this.format = format;
this.messageReaderSettings = messageReaderSettings;
this.version = version;
this.readingResponse = readingResponse;
this.synchronous = synchronous;
this.model = model;
this.urlResolver = urlResolver;
}
/// <summary>
/// Creates an instance of the output context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageWriterSettings">Configuration settings of the OData writer.</param>
/// <param name="writingResponse">true if writing a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs written to the payload.</param>
/// <returns>Task which represents the pending create operation.</returns>
internal static Task <ODataOutputContext> CreateOutputContextAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageWriterSettings messageWriterSettings,
bool writingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
//// Metadata output is only supported in synchronous operation.
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return(ODataRawOutputContext.CreateAsync(
format,
message,
encoding,
messageWriterSettings,
writingResponse,
model,
urlResolver));
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
/// <summary>
/// Determine the <see cref="ODataFormat"/> to use for the given <paramref name="contentTypeHeader"/>. If no supported content type
/// is found an exception is thrown.
/// </summary>
/// <param name="contentTypeHeader">The name of the content type to be checked.</param>
/// <param name="supportedPayloadKinds">All possiblel kinds of payload that can be read with this content type.</param>
/// <param name="mediaTypeResolver">The media type resolver to use when interpreting the content type.</param>
/// <param name="mediaType">The media type parsed from the <paramref name="contentTypeHeader"/>.</param>
/// <param name="encoding">The encoding from the content type or the default encoding for the <paramref name="mediaType" />.</param>
/// <param name="selectedPayloadKind">
/// The payload kind that was selected form the list of <paramref name="supportedPayloadKinds"/> for the
/// specified <paramref name="contentTypeHeader"/>.
/// </param>
/// <param name="batchBoundary">The batch boundary read from the content type for batch payloads; otherwise null.</param>
/// <returns>The <see cref="ODataFormat"/> for the <paramref name="contentTypeHeader"/>.</returns>
internal static ODataFormat GetFormatFromContentType(
string contentTypeHeader,
ODataPayloadKind[] supportedPayloadKinds,
MediaTypeResolver mediaTypeResolver,
out MediaType mediaType,
out Encoding encoding,
out ODataPayloadKind selectedPayloadKind,
out string batchBoundary)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported), "!supportedPayloadKinds.Contains(ODataPayloadKind.Unsupported)");
ODataFormat format = GetFormatFromContentType(contentTypeHeader, supportedPayloadKinds, mediaTypeResolver, out mediaType, out encoding, out selectedPayloadKind);
// for batch payloads, read the batch boundary from the content type header; this is the only
// content type parameter we support (and that is required for batch payloads)
if (selectedPayloadKind == ODataPayloadKind.Batch)
{
KeyValuePair <string, string> boundaryPair = default(KeyValuePair <string, string>);
IEnumerable <KeyValuePair <string, string> > parameters = mediaType.Parameters;
if (parameters != null)
{
bool boundaryPairFound = false;
foreach (KeyValuePair <string, string> pair in parameters.Where(p => HttpUtils.CompareMediaTypeParameterNames(ODataConstants.HttpMultipartBoundary, p.Key)))
{
if (boundaryPairFound)
{
throw new ODataException(Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, ODataConstants.HttpMultipartBoundary));
}
boundaryPair = pair;
boundaryPairFound = true;
}
}
if (boundaryPair.Key == null)
{
throw new ODataException(Strings.MediaTypeUtils_BoundaryMustBeSpecifiedForBatchPayloads(contentTypeHeader, ODataConstants.HttpMultipartBoundary));
}
batchBoundary = boundaryPair.Value;
ValidationUtils.ValidateBoundaryString(batchBoundary);
}
else
{
batchBoundary = null;
}
return(format);
}
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull <ODataMessageWriterSettings>(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.writerBehavior = settings.writerBehavior;
}
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull<ODataMessageWriterSettings>(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.writerBehavior = settings.writerBehavior;
}
internal static Task <ODataInputContext> CreateInputContextAsync(ODataFormat format, ODataPayloadKind readerPayloadKind, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return(ODataAtomInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver));
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
return(ODataRawInputContext.CreateAsync(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver, readerPayloadKind));
}
private ODataMetadataOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.xmlWriter = ODataAtomWriterUtils.CreateXmlWriter(messageStream, messageWriterSettings, encoding);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
internal static Task <ODataOutputContext> CreateOutputContextAsync(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return(ODataAtomOutputContext.CreateAsync(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonOutputContext.CreateAsync(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataOutputContext_CreateOutputContext_UnrecognizedFormat));
}
return(ODataRawOutputContext.CreateAsync(format, message, encoding, messageWriterSettings, writingResponse, model, urlResolver));
}
internal ODataJsonInputContext(ODataFormat format, TextReader reader, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
try
{
this.textReader = reader;
this.jsonReader = new BufferingJsonReader(this.textReader, base.UseServerFormatBehavior, messageReaderSettings.MessageQuotas.MaxNestingDepth);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (reader != null))
{
reader.Dispose();
}
throw;
}
}
private ODataMetadataInputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
try
{
this.baseXmlReader = ODataAtomReaderUtils.CreateXmlReader(messageStream, encoding, messageReaderSettings);
this.xmlReader = new BufferingXmlReader(this.baseXmlReader, null, messageReaderSettings.BaseUri, false, messageReaderSettings.MessageQuotas.MaxNestingDepth, messageReaderSettings.ReaderBehavior.ODataNamespace);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private ODataMetadataInputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
ExceptionUtils.CheckArgumentNotNull <ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull <ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
try
{
this.baseXmlReader = ODataAtomReaderUtils.CreateXmlReader(messageStream, encoding, messageReaderSettings);
this.xmlReader = new BufferingXmlReader(this.baseXmlReader, null, messageReaderSettings.BaseUri, false, messageReaderSettings.MessageQuotas.MaxNestingDepth, messageReaderSettings.ReaderBehavior.ODataNamespace);
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private ODataRawInputContext(ODataFormat format, System.IO.Stream messageStream, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind) : base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
ExceptionUtils.CheckArgumentNotNull <ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull <ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
private ODataRawInputContext(ODataFormat format, System.IO.Stream messageStream, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind) : base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
ExceptionUtils.CheckArgumentNotNull<ODataFormat>(format, "format");
ExceptionUtils.CheckArgumentNotNull<ODataMessageReaderSettings>(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception exception)
{
if (ExceptionUtils.IsCatchableExceptionType(exception) && (messageStream != null))
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Gets the default media type for a given payload kind in a given format.
/// </summary>
/// <param name="supportedMediaTypes">An array of supported media types and formats.</param>
/// <param name="specifiedFormat">The user-specified format in which to write the payload (can be null).</param>
/// <param name="actualFormat">The default format for the specified payload kind</param>
/// <returns>The default media type for the given payload kind and format.</returns>
private static MediaType GetDefaultMediaType(
MediaTypeWithFormat[] supportedMediaTypes,
ODataFormat specifiedFormat,
out ODataFormat actualFormat)
{
for (int i = 0; i < supportedMediaTypes.Length; ++i)
{
// NOTE: the supportedMediaTypes are sorted (desc) by format and media type; so the
// default format and media type is the first entry in the array
MediaTypeWithFormat supportedMediaType = supportedMediaTypes[i];
if (specifiedFormat == null || supportedMediaType.Format == specifiedFormat)
{
actualFormat = supportedMediaType.Format;
return(supportedMediaType.MediaType);
}
}
throw new ODataException(Strings.ODataUtils_DidNotFindDefaultMediaType(specifiedFormat));
}
/// <summary>Constructor.</summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageStream">The stream to read data from.</param>
/// <param name="encoding">The encoding to use to read the input.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</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="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
internal ODataMetadataInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageStream != null, "stream != null");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.baseXmlReader = ODataAtomReaderUtils.CreateXmlReader(messageStream, encoding, messageReaderSettings);
// We use the buffering reader here only for in-stream error detection (not for buffering).
this.xmlReader = new BufferingXmlReader(
this.baseXmlReader,
/*parentXmlReader*/ null,
messageReaderSettings.BaseUri,
/*disableXmlBase*/ false,
messageReaderSettings.MessageQuotas.MaxNestingDepth,
messageReaderSettings.ReaderBehavior.ODataNamespace);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>Constructor.</summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageStream">The stream to read data from.</param>
/// <param name="encoding">The encoding to use to read the input.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</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="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
internal ODataAtomInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageStream != null, "stream != null");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.baseXmlReader = ODataAtomReaderUtils.CreateXmlReader(messageStream, encoding, messageReaderSettings);
// For WCF DS Server behavior we need to turn off xml:base processing for V1/V2 back compat.
this.xmlReader = new BufferingXmlReader(
this.baseXmlReader,
/*parentXmlReader*/ null,
messageReaderSettings.BaseUri,
/*disableXmlBase*/ this.UseServerFormatBehavior && this.Version < ODataVersion.V3,
messageReaderSettings.MessageQuotas.MaxNestingDepth,
messageReaderSettings.ReaderBehavior.ODataNamespace);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>
/// Copy constructor to create a copy of the settings for OData writers.
/// </summary>
/// <param name="settings">Settings to create a copy from</param>
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.atomFormatStartEntryXmlCustomizationCallback = settings.atomFormatStartEntryXmlCustomizationCallback;
this.atomFormatEndEntryXmlCustomizationCallback = settings.atomFormatEndEntryXmlCustomizationCallback;
// NOTE: writer behavior is immutable; copy by reference is ok.
this.writerBehavior = settings.writerBehavior;
}
/// <summary>Constructor.</summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageStream">The stream to read data from.</param>
/// <param name="encoding">The encoding to use to read the input.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</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="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
private ODataMetadataInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
Debug.Assert(messageStream != null, "stream != null");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.baseXmlReader = ODataAtomReaderUtils.CreateXmlReader(messageStream, encoding, messageReaderSettings);
// We use the buffering reader here only for in-stream error detection (not for buffering).
this.xmlReader = new BufferingXmlReader(
this.baseXmlReader,
/*parentXmlReader*/ null,
messageReaderSettings.BaseUri,
/*disableXmlBase*/ false,
messageReaderSettings.MessageQuotas.MaxNestingDepth,
messageReaderSettings.ReaderBehavior.ODataNamespace);
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
private ODataRawOutputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageWriterSettings messageWriterSettings, bool writingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : base(format, messageWriterSettings, writingResponse, synchronous, model, urlResolver)
{
try
{
this.messageOutputStream = messageStream;
this.encoding = encoding;
if (synchronous)
{
this.outputStream = messageStream;
}
else
{
this.asynchronousOutputStream = new AsyncBufferedStream(messageStream);
this.outputStream = this.asynchronousOutputStream;
}
}
catch
{
messageStream.Dispose();
throw;
}
}
/// <summary>Constructor.</summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageStream">The stream to read data from.</param>
/// <param name="encoding">The encoding to use to read the input.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</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="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
internal ODataRawInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(messageStream != null, "stream != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
/// <summary>Constructor.</summary>
/// <param name="format">The format for this input context.</param>
/// <param name="messageStream">The stream to read data from.</param>
/// <param name="encoding">The encoding to use to read the input.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</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="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
private ODataRawInputContext(
ODataFormat format,
Stream messageStream,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
bool synchronous,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
: base(format, messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
Debug.Assert(messageStream != null, "stream != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
ExceptionUtils.CheckArgumentNotNull(format, "format");
ExceptionUtils.CheckArgumentNotNull(messageReaderSettings, "messageReaderSettings");
try
{
this.stream = messageStream;
this.encoding = encoding;
this.readerPayloadKind = readerPayloadKind;
}
catch (Exception e)
{
// Dispose the message stream if we failed to create the input context.
if (ExceptionUtils.IsCatchableExceptionType(e) && messageStream != null)
{
messageStream.Dispose();
}
throw;
}
}
public ODataResponseContext(IODataRequestMessage requestMessage, ODataFormat format, ODataVersion version, Uri baseAddress, string serviceOperationName)
{
if (requestMessage == null)
{
throw Error.ArgumentNull("requestMessage");
}
if (baseAddress == null)
{
throw Error.ArgumentNull("baseAddress");
}
if (String.IsNullOrEmpty(serviceOperationName))
{
throw Error.ArgumentNullOrEmpty("serviceOperationName");
}
_requestMessage = requestMessage;
ODataFormat = format;
ODataVersion = version;
_baseAddress = baseAddress;
_serviceOperationName = serviceOperationName;
IsIndented = true;
}
internal static ODataInputContext CreateInputContext(ODataFormat format, ODataPayloadKind readerPayloadKind, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
if (format == ODataFormat.Atom)
{
return ODataAtomInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if (format == ODataFormat.VerboseJson)
{
return ODataJsonInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if (format == ODataFormat.Metadata)
{
return ODataMetadataInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver);
}
if ((format != ODataFormat.Batch) && (format != ODataFormat.RawValue))
{
throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
return ODataRawInputContext.Create(format, message, encoding, messageReaderSettings, version, readingResponse, model, urlResolver, readerPayloadKind);
}
internal ODataJsonInputContext(ODataFormat format, Stream messageStream, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, bool synchronous, IEdmModel model, IODataUrlResolver urlResolver) : this(format, CreateTextReaderForMessageStreamConstructor(messageStream, encoding), messageReaderSettings, version, readingResponse, synchronous, model, urlResolver)
{
}
/// <summary>
/// Creates an instance of the input context for the specified format.
/// </summary>
/// <param name="format">The format to create the context for.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext CreateInputContext(
ODataFormat format,
ODataPayloadKind readerPayloadKind,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
if (format == ODataFormat.Atom)
{
return(ODataAtomInputContext.Create(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver));
}
if (format == ODataFormat.VerboseJson)
{
return(ODataJsonInputContext.Create(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver));
}
if (format == ODataFormat.Metadata)
{
return(ODataMetadataInputContext.Create(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver));
}
if (format == ODataFormat.Batch || format == ODataFormat.RawValue)
{
return(ODataRawInputContext.Create(
format,
message,
encoding,
messageReaderSettings,
version,
readingResponse,
model,
urlResolver,
readerPayloadKind));
}
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.ODataInputContext_CreateInputContext_UnrecognizedFormat));
}
private static ODataMessageWriterSettings CreateMessageWriterSettings(Uri serviceUri, DataServiceProviderWrapper provider, Version responseVersion, bool disableDisposeStream, ODataFormat format)
{
ODataMessageWriterSettings settings = new ODataMessageWriterSettings {
BaseUri = serviceUri,
Version = new ODataVersion?(CommonUtil.ConvertToODataVersion(responseVersion)),
Indent = false,
CheckCharacters = false,
DisableMessageStreamDisposal = disableDisposeStream
};
settings.EnableWcfDataServicesServerBehavior(provider.IsV1Provider);
settings.SetContentType(format);
return settings;
}
private IEnumerable<KeyValuePair<string, string>> GetResponseMessageHeaders(Type graphType, ODataFormat odataFormat, ODataVersion version)
{
IODataResponseMessage responseMessage = new ODataMessageWrapper();
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = new Uri(ODataFormatterConstants.DefaultNamespace),
Version = version,
Indent = false
};
writerSettings.SetContentType(odataFormat);
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings))
{
ODataSerializer serializer = ODataSerializerProvider.GetODataPayloadSerializer(graphType);
// get the OData specific headers for the payloadkind
ODataUtils.SetHeadersForPayload(messageWriter, serializer.ODataPayloadKind);
}
return responseMessage.Headers;
}
/// <summary>
/// Create RAW input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
Stream messageStream = message.GetStream();
return new ODataRawInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver,
readerPayloadKind);
}
/// <summary>
/// Create ATOM input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>The newly created input context.</returns>
internal static ODataInputContext Create(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Stream messageStream = message.GetStream();
return new ODataAtomInputContext(
format,
messageStream,
encoding,
messageReaderSettings,
version,
readingResponse,
true,
model,
urlResolver);
}
internal static ODataInputContext Create(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind)
{
return new ODataRawInputContext(format, message.GetStream(), encoding, messageReaderSettings, version, readingResponse, true, model, urlResolver, readerPayloadKind);
}
/// <summary>
/// Asynchronously create ATOM input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <returns>Task which when completed returns the newly create input context.</returns>
internal static Task<ODataInputContext> CreateAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
return message.GetStreamAsync()
.FollowOnSuccessWith(
(streamTask) => (ODataInputContext)new ODataAtomInputContext(
format,
streamTask.Result,
encoding,
messageReaderSettings,
version,
readingResponse,
false,
model,
urlResolver));
}
internal static ODataInputContext Create(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver)
{
return(new ODataMetadataInputContext(format, message.GetStream(), encoding, messageReaderSettings, version, readingResponse, true, model, urlResolver));
}
/// <summary>
/// Copy constructor to create a copy of the settings for OData writers.
/// </summary>
/// <param name="settings">Settings to create a copy from</param>
public ODataMessageWriterSettings(ODataMessageWriterSettings settings)
{
ExceptionUtils.CheckArgumentNotNull(settings, "settings");
this.acceptCharSets = settings.acceptCharSets;
this.acceptMediaTypes = settings.acceptMediaTypes;
this.BaseUri = settings.BaseUri;
this.CheckCharacters = settings.CheckCharacters;
this.DisableMessageStreamDisposal = settings.DisableMessageStreamDisposal;
this.format = settings.format;
this.Indent = settings.Indent;
this.messageQuotas = new ODataMessageQuotas(settings.MessageQuotas);
this.useFormat = settings.useFormat;
this.Version = settings.Version;
this.atomFormatStartEntryXmlCustomizationCallback = settings.atomFormatStartEntryXmlCustomizationCallback;
this.atomFormatEndEntryXmlCustomizationCallback = settings.atomFormatEndEntryXmlCustomizationCallback;
// NOTE: writer behavior is immutable; copy by reference is ok.
this.writerBehavior = settings.writerBehavior;
}
/// <summary>
/// Asynchronously create RAW input context.
/// </summary>
/// <param name="format">The format for the input context.</param>
/// <param name="message">The message to use.</param>
/// <param name="encoding">The encoding to use.</param>
/// <param name="messageReaderSettings">Configuration settings of the OData reader.</param>
/// <param name="version">The OData protocol version to be used for reading the payload.</param>
/// <param name="readingResponse">true if reading a response message; otherwise false.</param>
/// <param name="model">The model to use.</param>
/// <param name="urlResolver">The optional URL resolver to perform custom URL resolution for URLs read from the payload.</param>
/// <param name="readerPayloadKind">The <see cref="ODataPayloadKind"/> to read.</param>
/// <returns>Task which when completed returns the newly create input context.</returns>
internal static Task<ODataInputContext> CreateAsync(
ODataFormat format,
ODataMessage message,
Encoding encoding,
ODataMessageReaderSettings messageReaderSettings,
ODataVersion version,
bool readingResponse,
IEdmModel model,
IODataUrlResolver urlResolver,
ODataPayloadKind readerPayloadKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(format == ODataFormat.RawValue || format == ODataFormat.Batch, "This method only supports the RAW value or batch format.");
Debug.Assert(message != null, "message != null");
Debug.Assert(messageReaderSettings != null, "messageReaderSettings != null");
Debug.Assert(readerPayloadKind != ODataPayloadKind.Unsupported, "readerPayloadKind != ODataPayloadKind.Unsupported");
// TODO: Note that this will buffer the entire input. We need this for batch and for raw values since they
// both use TextReader - verify that this is really what we want to do.
return message.GetStreamAsync()
.FollowOnSuccessWith(
(streamTask) => (ODataInputContext)new ODataRawInputContext(
format,
streamTask.Result,
encoding,
messageReaderSettings,
version,
readingResponse,
false,
model,
urlResolver,
readerPayloadKind));
}
private static MediaType GetDefaultMediaType(MediaTypeWithFormat[] supportedMediaTypes, ODataFormat specifiedFormat, out ODataFormat actualFormat)
{
for (int i = 0; i < supportedMediaTypes.Length; i++)
{
MediaTypeWithFormat format = supportedMediaTypes[i];
if ((specifiedFormat == null) || (format.Format == specifiedFormat))
{
actualFormat = format.Format;
return(format.MediaType);
}
}
throw new ODataException(Microsoft.Data.OData.Strings.ODataUtils_DidNotFindDefaultMediaType(specifiedFormat));
}
/// <summary>
/// Inserts the specified media type before the first occurrence of <paramref name="beforeFormat"/>.
/// </summary>
/// <param name="mediaTypeList">The media type list to insert into.</param>
/// <param name="mediaTypeToInsert">The media type to insert.</param>
/// <param name="beforeFormat">The format of the media type before which <paramref name="mediaTypeToInsert"/> should be inserted.</param>
private static void AddMediaTypeEntryOrdered(IList <MediaTypeWithFormat> mediaTypeList, MediaTypeWithFormat mediaTypeToInsert, ODataFormat beforeFormat)
{
Debug.Assert(mediaTypeList != null, "mediaTypeList != null");
Debug.Assert(mediaTypeToInsert != null, "mediaTypeToInsert != null");
Debug.Assert(beforeFormat != null, "beforeFormat != null");
// Go through the list and find the first entry that has the specified format to insert before.
for (int i = 0; i < mediaTypeList.Count; ++i)
{
if (mediaTypeList[i].Format == beforeFormat)
{
mediaTypeList.Insert(i, mediaTypeToInsert);
return;
}
}
mediaTypeList.Add(mediaTypeToInsert);
}
internal static ODataMessageWriter CreateMessageWriter(Uri serviceUri, IDataService dataService, Version responseVersion, IODataResponseMessage responseMessage, ODataFormat format)
{
return new ODataMessageWriter(responseMessage, CreateMessageWriterSettings(serviceUri, dataService.Provider, responseVersion, responseMessage is System.Data.Services.ODataResponseMessage, format), (dataService.OperationContext == null) ? null : dataService.Provider.GetMetadataModel(dataService.OperationContext));
}
internal static Task<ODataInputContext> CreateAsync(ODataFormat format, ODataMessage message, Encoding encoding, ODataMessageReaderSettings messageReaderSettings, ODataVersion version, bool readingResponse, IEdmModel model, IODataUrlResolver urlResolver, ODataPayloadKind readerPayloadKind)
{
return message.GetStreamAsync().FollowOnSuccessWith<System.IO.Stream, ODataInputContext>(streamTask => new ODataRawInputContext(format, streamTask.Result, encoding, messageReaderSettings, version, readingResponse, false, model, urlResolver, readerPayloadKind));
}
/// <summary>
/// Inserts the given media type/format for all the payload kinds which support JSON before the first media type with the given format.
/// </summary>
/// <param name="mediaTypeWithFormat">The media type/format pair to add.</param>
/// <param name="beforeFormat">The format of the media type before which <paramref name="mediaTypeWithFormat"/> should be inserted.</param>
private void InsertForJsonPayloadKinds(MediaTypeWithFormat mediaTypeWithFormat, ODataFormat beforeFormat)
{
foreach (ODataPayloadKind kind in JsonPayloadKinds)
{
AddMediaTypeEntryOrdered(this.mediaTypesForPayloadKind[(int)kind], mediaTypeWithFormat, beforeFormat);
}
}