// Sealed because derived classes shouldn't override the async version. Override sync version instead.
public sealed override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
// Underlying stream will do encoding into separate sections. This is just buffering.
return TaskHelpers.RunSynchronously(
() =>
{
Stream bufferedStream = GetBufferStream(stream);
try
{
WriteToStream(type, value, bufferedStream, contentHeaders);
}
finally
{
// Disposing the bufferStream will dispose the underlying stream.
// So Flush any remaining bytes that have been written, but don't actually close the stream.
bufferedStream.Flush();
}
});
}
public Task CopyToAsync (Stream stream, TransportContext context)
{
if (stream == null)
throw new ArgumentNullException ("stream");
return SerializeToStreamAsync (stream, context);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Debug.Assert(stream != null);
if (_contentConsumed)
{
throw new InvalidOperationException(SR.net_http_content_stream_already_read);
}
_contentConsumed = true;
const int BufferSize = 8192;
Task copyTask = _content.CopyToAsync(stream, BufferSize, _cancellationToken);
if (copyTask.IsCompleted)
{
try { _content.Dispose(); } catch { } // same as StreamToStreamCopy behavior
}
else
{
copyTask = copyTask.ContinueWith((t, s) =>
{
try { ((Stream)s).Dispose(); } catch { }
t.GetAwaiter().GetResult();
}, _content, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
}
return copyTask;
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
byte[] bytes = new byte[_sizeOfEachWrite];
for (int i = 0; i < _numberOfWrites; i++)
{
await stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Debug.Assert(stream != null);
PrepareContent();
// If the stream can't be re-read, make sure that it gets disposed once it is consumed.
return StreamToStreamCopy.CopyAsync(_content, stream, _bufferSize, !_content.CanSeek);
}
public override bool ConnectionRequest(TransportContext context)
{
TransportContextTCPIP tcpContext = context as TransportContextTCPIP;
IXimuraRQRSEnvelope Env = null;
try
{
Env = context.EnvelopeHelper.GetCallback(context.ServerCommandID.Value);
context.SenderIdentitySet(Env);
Env.DestinationAddress = new EnvelopeAddress(context.ServerCommandID.Value, "ConnRQ");
IXimuraProtocolConnectionRequest Request = Env.Request as IXimuraProtocolConnectionRequest;
IXimuraProtocolConnectionResponse Response = Env.Response as IXimuraProtocolConnectionResponse;
Request.ProtocolContextID = context.SignatureID;
Request.RemoteUri = context.UriRemote;
Request.LocalUri = context.UriLocal;
Request.ConnectionType = TransportConnectionType.Connectionful;
//We want a new server context, so we will not send an ID.
Request.ServerContextID = context.ServerContextID;
context.ContextSession.ProcessRequest(Env);
if (Env.Response.Status != CH.HTTPCodes.OK_200)
{
return false;
}
context.ServerContextID = Response.ServerContextID;
context.MessageTypeIn = Response.MessageRequestType;
//context.FlowControl = Response.FlowControl;
if (Response.MessageResponse != null)
{
context.MessageTransmit(Response.MessageResponse);
}
context.ClosePending = Response.CloseNotify;
context.ConnectionStart();
return true;
}
catch (Exception ex)
{
return false;
}
finally
{
if (Env != null && Env.ObjectPoolCanReturn)
Env.ObjectPoolReturn();
}
return false;
}
public void CheckTransportContext(TransportContext context)
{
var cbt1 = context.GetChannelBinding(ChannelBindingKind.Endpoint);
var cbt2 = context.GetChannelBinding(ChannelBindingKind.Unique);
var cbt3 = context.GetChannelBinding(ChannelBindingKind.Unknown);
CheckChannelBinding(cbt1);
CheckChannelBinding(cbt2);
CheckChannelBinding(cbt3);
Assert.True(cbt1 != null, "ChannelBindingKind.Endpoint token data should be returned from SCHANNEL.");
Assert.True(cbt2 != null, "ChannelBindingKind.Unique token data should be returned from SCHANNEL.");
Assert.True(cbt3 == null, "ChannelBindingKind.Unknown token data should not be returned from SCHANNEL since it does not map to a defined context attribute.");
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
if (SerializeToStreamAsyncCallback != null)
{
return SerializeToStreamAsyncCallback(stream, context);
}
else if (InnerContent != null)
{
return InnerContent.CopyToAsync(stream, context);
}
else
{
throw new InvalidOperationException("Construct with inner HttpContent or set SerializeToStreamCallback first.");
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();
try
{
Stream wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
_onStreamAvailable(wrappedStream, this, context);
}
catch (Exception e)
{
serializeToStreamTask.TrySetException(e);
}
return serializeToStreamTask.Task;
}
protected override void SerializeToStream(Stream stream, TransportContext context)
{
Contract.Assert(stream != null);
PrepareContent();
try
{
content.CopyTo(stream, bufferSize);
}
finally
{
// Make sure the source stream gets disposed if it can't be consumed multiple times.
if (!content.CanSeek)
{
content.Dispose();
}
}
}
// Sealed because derived classes shouldn't override the async version. Override sync version instead.
public sealed override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
return TaskHelpers.RunSynchronously(
() =>
{
using (Stream bufferedStream = GetBufferStream(writeStream, _bufferSizeInBytes))
{
WriteToStream(type, value, bufferedStream, content);
}
});
}
// Sealed because derived classes shouldn't override the async version. Override sync version instead.
public sealed override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
return TaskHelpers.RunSynchronously(
() =>
{
using (Stream bufferedStream = GetBufferStream(stream, _bufferSizeInBytes))
{
WriteToStream(type, value, bufferedStream, contentHeaders);
}
});
}
/// <summary>
/// Write a .NET object to an output stream
/// </summary>
/// <param name="type"></param>
/// <param name="value"></param>
/// <param name="writeStream"></param>
/// <param name="content"></param>
/// <param name="transportContext"></param>
/// <returns></returns>
public override Task WriteToStreamAsync(
Type type,
object value,
Stream writeStream,
HttpContent content,
TransportContext transportContext
)
{
return(Task.Factory.StartNew(() =>
{
if ((Json == null) || (Json.Count == 0) || RebuildJson)
{
if (ImplementsGenericType(typeof(FilteredResource <>), type))
{
PropertyInfo resourceProp = value.GetType().GetProperty("Resource");
Type[] actualTypeArguments = GetChildClassParameterArguments(typeof(FilteredResource <>), type);
object objects = resourceProp.GetValue(value, null);
PropertyInfo propertiesProp = value.GetType().GetProperty("Properties");
if (!ImplementsICollection(actualTypeArguments[0]))
{
objects = new EnumerableWrapper(objects);
}
if (ImplementsGenericType(typeof(ResponseInfo <>), type))
{
//Subject URI for the collection is the query capability
//TODO: should this be set by the app based on service provider info
int portNum = httpRequest.RequestUri.Port;
string portString = null;
if (portNum == 80 || portNum == 443)
{
portString = "";
}
else
{
portString = ":" + portNum.ToString();
}
string descriptionAbout = httpRequest.RequestUri.Scheme + "://" +
httpRequest.RequestUri.Host +
portString +
httpRequest.RequestUri.LocalPath;
//Subject URI for the responseInfo is the full request URI
string responseInfoAbout = httpRequest.RequestUri.ToString();
PropertyInfo totalCountProp = value.GetType().GetProperty("TotalCount");
PropertyInfo nextPageProp = value.GetType().GetProperty("NextPage");
Json = JsonHelper.CreateJson(descriptionAbout, responseInfoAbout,
(string)nextPageProp.GetValue(value, null),
(int)totalCountProp.GetValue(value, null),
objects as IEnumerable <object>,
(IDictionary <string, object>)propertiesProp.GetValue(value, null));
}
else
{
Json = JsonHelper.CreateJson(null, null, null, null, objects as IEnumerable <object>,
(IDictionary <string, object>)propertiesProp.GetValue(value, null));
}
}
else if (InheritedGenericInterfacesHelper.ImplementsGenericInterface(typeof(IEnumerable <>), value.GetType()))
{
Json = JsonHelper.CreateJson(value as IEnumerable <object>);
}
else if (type.GetCustomAttributes(typeof(OslcResourceShape), false).Length > 0)
{
Json = JsonHelper.CreateJson(new object[] { value });
}
else
{
Json = JsonHelper.CreateJson(new EnumerableWrapper(value));
}
Debug.WriteLine("JsonMediaTypeFormatter.WriteToStreamAsync(): Generated JSON: " + Json.ToString());
}
Json.Save(writeStream);
}));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Debug.Assert(stream != null);
return(stream.WriteAsync(_content, _offset, _count));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return(_func(stream));
}
/// <summary>
/// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
/// <param name="context">The associated <see cref="TransportContext"/>.</param>
/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return(_formatter.WriteToStreamAsync(ObjectType, Value, stream, this, context));
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
return(_innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
reset();
return(base.SerializeToStreamAsync(stream, context));
}
/// <summary>
/// Returns a <see cref="Task"/> that serializes the given <paramref name="value"/> of the given <paramref name="type"/>
/// to the given <paramref name="writeStream"/>.
/// </summary>
/// <remarks>
/// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
/// supports reading.</para>
/// <para>An implementation of this method should NOT close <paramref name="writeStream"/> upon completion. The stream will be closed independently when
/// the <see cref="HttpContent"/> instance is disposed.
/// </para>
/// </remarks>
/// <param name="type">The type of the object to write.</param>
/// <param name="value">The object value to write. It may be <c>null</c>.</param>
/// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
/// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
/// <param name="transportContext">The <see cref="TransportContext"/> if available. It may be <c>null</c>.</param>
/// <returns>A <see cref="Task"/> that will perform the write.</returns>
/// <exception cref="NotSupportedException">Derived types need to support writing.</exception>
/// <seealso cref="CanWriteType(Type)"/>
public virtual Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
// HttpContent.SerializeToStreamAsync doesn't take in a CancellationToken. So, there is no easy way to get the CancellationToken
// to the formatter while writing response. We are cheating here by passing fake cancellation tokens. We should fix this
// when we fix HttpContent.
return(WriteToStreamAsync(type, value, writeStream, content, transportContext, CancellationToken.None));
}
/// <summary>Serialize an object into the stream.</summary>
/// <param name="type">The type of object to write.</param>
/// <param name="value">The object instance to write.</param>
/// <param name="stream">The stream to which to write.</param>
/// <param name="contentHeaders">The HTTP content headers for the content being written.</param>
/// <param name="transportContext">The <see cref="TransportContext"/>.</param>
public override void Serialize(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, TransportContext transportContext)
{
JsonSerializer serializer = new JsonSerializer();
BsonWriter writer = new BsonWriter(stream);
serializer.Serialize(writer, value);
}
protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)
{
if (type == typeof(JsonObject))
{
return(Task.Factory.StartNew(() =>
{
var pairs = new List <string>();
Flatten(pairs, value as JsonObject);
var bytes = encoding.GetBytes(string.Join("&", pairs));
stream.Write(bytes, 0, bytes.Length);
}));
}
else
{
return(base.OnWriteToStreamAsync(type, value, stream, contentHeaders, formatterContext, transportContext));
}
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
throw new NotImplementedException();
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
return(Task.Factory.StartNew(() =>
{
using (StreamWriter streamwriter = new StreamWriter(writeStream))
using (JsonWriter writer = new JsonTextWriter(streamwriter))
{
var summary = requestMessage.RequestSummary();
if (type == typeof(OperationOutcome))
{
Resource resource = (Resource)value;
FhirSerializer.SerializeResource(resource, writer);
}
else if (typeof(Resource).IsAssignableFrom(type))
{
Resource resource = (Resource)value;
FhirSerializer.SerializeResource(resource, writer);
}
else if (typeof(FhirResponse).IsAssignableFrom(type))
{
FhirResponse response = (value as FhirResponse);
if (response.HasBody)
{
FhirSerializer.SerializeResource(response.Resource, writer, summary);
}
}
}
}));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken) => // Only skip the original protected virtual SerializeToStreamAsync if this // isn't a derived type that may have overridden the behavior. GetType() == typeof(StringContent) ? SerializeToStreamAsyncCore(stream, cancellationToken) : base.SerializeToStreamAsync(stream, context, cancellationToken);
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
return(Task.Run(() => Serialize(type, value, writeStream, content)));
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
MediaTypeHeaderValue contentType = contentHeaders == null
? null
: contentHeaders.ContentType;
return(TraceWriter.TraceBeginEndAsync(
Request,
TraceCategories.FormattingCategory,
TraceLevel.Info,
InnerFormatter.GetType().Name,
WriteToStreamAsyncMethodName,
beginTrace: (tr) =>
{
tr.Message = Error.Format(
SRResources.TraceWriteToStreamMessage,
FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture),
type.Name,
contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
},
execute: () => InnerFormatter.WriteToStreamAsync(type, value, writeStream, content, transportContext),
endTrace: null,
errorTrace: null));
}
/// <summary>
/// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
/// <param name="context">The associated <see cref="TransportContext"/>.</param>
/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
#if NETFX_CORE
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
if (stream == null)
{
throw Error.ArgumentNull("stream");
}
byte[] header = SerializeHeader();
await stream.WriteAsync(header, 0, header.Length);
if (Content != null)
{
Stream readStream = await _streamTask.Value;
ValidateStreamForReading(readStream);
await Content.CopyToAsync(stream);
}
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
var task = Task.Factory.StartNew(() =>
{
string json = JsonConvert.SerializeObject(value, this.SerializerSettings);
byte[] buf = Encoding.Default.GetBytes(json);
writeStream.Write(buf, 0, buf.Length);
writeStream.Flush();
});
return(task);
}
/// <summary>
/// Returns a <see cref="Task"/> that serializes the given <paramref name="value"/> of the given <paramref name="type"/>
/// to the given <paramref name="writeStream"/>.
/// </summary>
/// <remarks>
/// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
/// supports reading.</para>
/// <para>An implementation of this method should NOT close <paramref name="writeStream"/> upon completion. The stream will be closed independently when
/// the <see cref="HttpContent"/> instance is disposed.
/// </para>
/// </remarks>
/// <param name="type">The type of the object to write.</param>
/// <param name="value">The object value to write. It may be <c>null</c>.</param>
/// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
/// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
/// <param name="transportContext">The <see cref="TransportContext"/> if available. It may be <c>null</c>.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
/// <returns>A <see cref="Task"/> that will perform the write.</returns>
/// <exception cref="NotSupportedException">Derived types need to support writing.</exception>
/// <seealso cref="CanWriteType(Type)"/>
public virtual Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext, CancellationToken cancellationToken)
{
throw Error.NotSupported(Properties.Resources.MediaTypeFormatterCannotWrite, GetType().Name);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Debug.Assert(stream != null);
return stream.WriteAsync(_content, _offset, _count);
}
protected sealed override Task SerializeToStreamAsync(Stream stream, TransportContext context) => SerializeToStreamAsync(stream, context, CancellationToken.None);
/// <summary>
/// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
/// </summary>
/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
/// <param name="context">The associated <see cref="TransportContext"/>.</param>
/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return _formatter.WriteToStreamAsync(ObjectType, Value, stream, this, context);
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
byte[] byteArray = Encoding.ASCII.GetBytes(string.Empty);
await stream.WriteAsync(byteArray, 0, 0);
}
public Task CopyToAsync(Stream stream, TransportContext context)
{
CheckDisposed();
if (stream == null)
{
throw new ArgumentNullException("stream");
}
TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
try
{
Task task = null;
if (IsBuffered)
{
byte[] data = this.GetDataBuffer(_bufferedContent);
task = stream.WriteAsync(data, 0, (int)_bufferedContent.Length);
}
else
{
task = SerializeToStreamAsync(stream, context);
CheckTaskNotNull(task);
}
// If the copy operation fails, wrap the exception in an HttpRequestException() if appropriate.
task.ContinueWithStandard(tcs, (copyTask, state) =>
{
var innerTcs = (TaskCompletionSource<object>)state;
if (copyTask.IsFaulted)
{
innerTcs.TrySetException(GetStreamCopyException(copyTask.Exception.GetBaseException()));
}
else if (copyTask.IsCanceled)
{
innerTcs.TrySetCanceled();
}
else
{
innerTcs.TrySetResult(null);
}
});
}
catch (IOException e)
{
tcs.TrySetException(GetStreamCopyException(e));
}
catch (ObjectDisposedException e)
{
tcs.TrySetException(GetStreamCopyException(e));
}
return tcs.Task;
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
action(stream, tcs);
return(tcs.Task);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return SerializeToStreamAsyncDelegate != null ?
SerializeToStreamAsyncDelegate(stream, context) :
Task.CompletedTask;
}
protected abstract Task SerializeToStreamAsync(Stream stream, TransportContext context);
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var streamWriter = new StreamWriter(stream);
var writer = new JsonTextWriter(streamWriter);
writer.WriteStartArray();
foreach (var result in results)
{
if (result == null)
{
writer.WriteNull();
continue;
}
writer.WriteStartObject();
writer.WritePropertyName("Status");
writer.WriteValue((int)result.StatusCode);
writer.WritePropertyName("Headers");
writer.WriteStartObject();
foreach (var header in result.Headers.Concat(result.Content.Headers))
{
foreach (var val in header.Value)
{
writer.WritePropertyName(header.Key);
writer.WriteValue(val);
}
}
writer.WriteEndObject();
writer.WritePropertyName("Result");
var jsonContent = result.Content as JsonContent;
if (jsonContent != null && jsonContent.Data != null)
{
jsonContent.Data.WriteTo(writer, Default.Converters);
}
else
{
var stringContent = result.Content as MultiGetSafeStringContent;
if (stringContent != null)
{
writer.WriteStartObject();
writer.WritePropertyName("Error");
writer.WriteValue(stringContent.Content);
writer.WriteEndObject();
}
else
{
writer.WriteStartObject();
writer.WritePropertyName("Error");
writer.WriteValue("Content not valid for multi_get " + result.Content);
writer.WriteEndObject();
}
}
writer.WriteEndObject();
}
writer.WriteEndArray();
writer.Flush();
return(new CompletedTask());
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
TransportContext transportContext, CancellationToken cancellationToken)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
if (cancellationToken.IsCancellationRequested)
{
return TaskHelpers.Canceled();
}
try
{
WriteToStream(type, value, writeStream, content);
return TaskHelpers.Completed();
}
catch (Exception e)
{
return TaskHelpers.FromError(e);
}
}
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();
Stream wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
await _onStreamAvailable(wrappedStream, this, context);
// wait for wrappedStream.Close/Dispose to get called.
await serializeToStreamTask.Task;
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return(Task.FromResult <object>(null));
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
if (Request == null)
{
throw Error.NotSupported(SRResources.WriteToStreamAsyncMustHaveRequest);
}
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
return(TaskHelpers.RunSynchronously(() =>
{
// Get the format and version to use from the ODataServiceVersion content header or if not available use the
// values configured for the specialized formatter instance.
ODataVersion version;
if (contentHeaders == null)
{
version = _defaultODataVersion;
}
else
{
version = GetODataVersion(contentHeaders, ODataFormatterConstants.ODataServiceVersion) ?? _defaultODataVersion;
}
// get the most appropriate serializer given that we support inheritance.
type = value == null ? type : value.GetType();
ODataSerializer serializer = ODataSerializerProvider.GetODataPayloadSerializer(type);
if (serializer == null)
{
throw Error.InvalidOperation(SRResources.TypeCannotBeSerialized, type.Name, typeof(ODataMediaTypeFormatter).Name);
}
UrlHelper urlHelper = Request.GetUrlHelper();
IEdmEntitySet targetEntitySet = null;
ODataUriHelpers.TryGetEntitySetAndEntityType(Request.RequestUri, Model, out targetEntitySet);
// serialize a response
Uri baseAddress = new Uri(Request.RequestUri, Request.GetConfiguration().VirtualPathRoot);
// TODO: Bug 467617: figure out the story for the operation name on the client side and server side.
// This is clearly a workaround. We are assuming that the operation name is the last segment in the request uri
// which works for most cases and fall back to the type name of the object being written.
// We should rather use uri parser semantic tree to figure out the operation name from the request url.
string operationName = ODataUriHelpers.GetOperationName(Request.RequestUri, baseAddress);
operationName = operationName ?? type.Name;
IODataResponseMessage responseMessage = new ODataMessageWrapper(writeStream);
// TODO: Issue 483: http://aspnetwebstack.codeplex.com/workitem/483
// We need to set the MetadataDocumentUri when this property is added to ODataMessageWriterSettings as
// part of the JSON Light work.
// This is required so ODataLib can coerce AbsoluteUri's into RelativeUri's when appropriate in JSON Light.
ODataMessageWriterSettings writerSettings = new ODataMessageWriterSettings()
{
BaseUri = baseAddress,
Version = version,
Indent = true,
DisableMessageStreamDisposal = true
};
if (contentHeaders != null && contentHeaders.ContentType != null)
{
writerSettings.SetContentType(contentHeaders.ContentType.ToString(), Encoding.UTF8.WebName);
}
using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, writerSettings, ODataDeserializerProvider.EdmModel))
{
ODataSerializerContext writeContext = new ODataSerializerContext()
{
EntitySet = targetEntitySet,
UrlHelper = urlHelper,
ServiceOperationName = operationName,
SkipExpensiveAvailabilityChecks = serializer.ODataPayloadKind == ODataPayloadKind.Feed,
Request = Request
};
serializer.WriteObject(value, messageWriter, writeContext);
}
}));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
ChannelBinding = context.GetChannelBinding(ChannelBindingKind.Endpoint);
return base.SerializeToStreamAsync(stream, context);
}
public async Task WriteToStream(Stream outputStream, HttpContent content, TransportContext context)
{
try
{
var buffer = new byte[65536];
using (var video = FileInfo.OpenRead())
{
if (End == -1)
{
End = video.Length;
}
var position = Start;
var bytesLeft = End - Start + 1;
video.Position = Start;
while (position <= End)
{
// what should i do here?
var bytesRead = video.Read(buffer, 0, (int)Math.Min(bytesLeft, buffer.Length));
await outputStream.WriteAsync(buffer, 0, bytesRead);
position += bytesRead;
bytesLeft = End - position + 1;
}
}
}
catch (Exception ex)
{
// fail silently
}
finally
{
outputStream.Close();
}
}
/// <summary>
/// Called during serialization to write an object of the specified <paramref name="type"/>
/// to the specified <paramref name="writeStream"/>.
/// </summary>
/// <param name="type">The type of object to write.</param>
/// <param name="value">The object to write.</param>
/// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
/// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
/// <param name="transportContext">The <see cref="TransportContext"/>.</param>
/// <returns>A <see cref="Task"/> that will write the value to the stream.</returns>
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (writeStream == null)
{
throw Error.ArgumentNull("writeStream");
}
#if !NETFX_CORE
if (UseDataContractJsonSerializer && Indent)
{
throw Error.NotSupported(Properties.Resources.UnsupportedIndent, typeof(DataContractJsonSerializer));
}
#endif
return TaskHelpers.RunSynchronously(() =>
{
Encoding effectiveEncoding = SelectCharacterEncoding(content == null ? null : content.Headers);
#if !NETFX_CORE
if (UseDataContractJsonSerializer)
{
if (MediaTypeFormatter.TryGetDelegatingTypeForIQueryableGenericOrSame(ref type))
{
if (value != null)
{
value = MediaTypeFormatter.GetTypeRemappingConstructor(type).Invoke(new object[] { value });
}
}
DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type);
using (XmlWriter writer = JsonReaderWriterFactory.CreateJsonWriter(writeStream, effectiveEncoding, ownsStream: false))
{
dataContractSerializer.WriteObject(writer, value);
}
}
else
#endif
{
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(new StreamWriter(writeStream, effectiveEncoding)) { CloseOutput = false })
{
if (Indent)
{
jsonTextWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
}
JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
jsonSerializer.Serialize(jsonTextWriter, value);
jsonTextWriter.Flush();
}
}
});
}
public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext)
{
var tcs = new TaskCompletionSource <object>();
try
{
Model.Serialize(stream, value);
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
return(tcs.Task);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) { throw new NotImplementedException(); }
protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
_sendingContent.SetResult(true);
await _connectionClosed;
await stream.WriteAsync(Encoding.UTF8.GetBytes(_longContent));
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
if (_syncCopy)
{
try
{
_stream.CopyTo(stream, 128); // arbitrary size likely to require multiple read/writes
return Task.CompletedTask;
}
catch (Exception exc)
{
return Task.FromException(exc);
}
}
return base.SerializeToStreamAsync(stream, context);
}
public override Task WriteToStreamAsync(Type type, object value,
Stream stream, HttpContent content, TransportContext transportContext)
{
writeStream(type, value, stream, content);
var tcs = new TaskCompletionSource <int>();
tcs.SetResult(0);
return(tcs.Task);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
var formatter = new JsonNetMediaTypeFormatter();
return formatter.WriteToStreamAsync(instance.GetType(), instance, stream, base.Headers, context);
}
public ApprovalStatusController(TransportContext transportContext)
{
_context = transportContext;
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
ProgressStream progressStream = new ProgressStream(stream, _handler, _request, response: null);
return _innerContent.CopyToAsync(progressStream);
}
public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
{
try
{
SetSerializer <imsx_POXEnvelopeType>(ImsxResponseSerializer);
return(base.WriteToStreamAsync(type, value, writeStream, content, transportContext));
}
catch (Exception)
{
return(base.WriteToStreamAsync(type, value, writeStream, content, transportContext));
}
}
protected internal abstract Task SerializeToStreamAsync(Stream stream, TransportContext context);
protected async override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
byte[] byteArray = Encoding.ASCII.GetBytes(Content);
await stream.WriteAsync(byteArray, 0, Content.Length);
}
public abstract Task SerializeToStreamAsyncPublic(Stream stream, TransportContext context);
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
SerializeToStreamAsyncCount++;
if ((_options & MockOptions.ReturnNullInCopyToAsync) != 0)
{
return null;
}
if ((_options & MockOptions.ThrowInAsyncSerializeMethods) != 0)
{
throw _customException;
}
return Task.Factory.StartNew(() =>
{
CheckThrow();
return stream.WriteAsync(_mockData, 0, _mockData.Length);
});
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
return SerializeToStreamAsyncPublic(stream, context);
}
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
{
Contract.Assert(stream != null);
// Serialize header
byte[] header = SerializeHeader();
TaskCompletionSource<object> writeTask = new TaskCompletionSource<object>();
try
{
// We don't use TaskFactory.FromAsync as it generates an FxCop CA908 error
Tuple<HttpMessageContent, Stream, TaskCompletionSource<object>> state =
new Tuple<HttpMessageContent, Stream, TaskCompletionSource<object>>(this, stream, writeTask);
IAsyncResult result = stream.BeginWrite(header, 0, header.Length, _onWriteComplete, state);
if (result.CompletedSynchronously)
{
WriteComplete(result, this, stream, writeTask);
}
}
catch (Exception e)
{
writeTask.TrySetException(e);
}
return writeTask.Task;
}
