// 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; }