/// <inheritdoc /> public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { Guard.NotNull(context, nameof(context)); Guard.NotNull(selectedEncoding, nameof(selectedEncoding)); MemoryStream result = new MemoryStream(); using (var writer = context.WriterFactory(result, selectedEncoding)) { this.WriteObject(writer, context.Object); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await writer.FlushAsync(); } result.Position = 0; var jsonResult = JToken.Load(new JsonTextReader(new StreamReader(result))); //{"result":null,"error":{"code":-32601,"message":"Method not found"},"id":1} JObject response = new JObject(); response["result"] = jsonResult; response["id"] = 1; response["error"] = null; using (var writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) { this.WriteObject(writer, response); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await writer.FlushAsync(); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context is null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding is null) { throw new ArgumentNullException(nameof(selectedEncoding)); } var response = context.HttpContext.Response; var type = context.ObjectType; var model = context.Object; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { if (writer is null) { throw new NullReferenceException(nameof(writer)); } var jsonValue = serializer.Serialize(type, model); writer.Write(jsonValue); await writer.FlushAsync(); } }
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { JsonSerializeOption option = null; if (context.Object is JsonResultWrapper wrapper) { option = wrapper.Option; } var hosting = context.HttpContext.RequestServices.GetService <JsonSerializeOptionHosting>(); if (hosting != null) { option = hosting.Option; } option = option ?? mvcOptions.JsonSerializeOption; var serializer = new JsonSerializer(option); using (var jsonWriter = new JsonWriter(writer)) { serializer.Serialize(context.Object, jsonWriter); } } return(Task.CompletedTask); }
private async Task WriteResponseBodyImplAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var response = context.HttpContext.Response; FieldsParserResult fieldsParserResult = default; if (!this.ShouldBypassPartialResponse(context.HttpContext)) { fieldsParserResult = this.fieldsParser.Parse(context.HttpContext.Request); if (fieldsParserResult.HasError && !this.options.IgnoreParseErrors) { response.StatusCode = 400; return; } } using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { this.WriteObject(writer, context.Object, fieldsParserResult); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await writer.FlushAsync(); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context) { //TODO maybe need wrapping logic? var value = context.Object; var xmlSerializer = GetCachedSerializer(context.ObjectType); var httpContext = context.HttpContext; var response = httpContext.Response; //Used so we get correct content-length var fileBufferingWriteStream = new FileBufferingWriteStream(); var responseStream = fileBufferingWriteStream; try { await using (var textWriter = context.WriterFactory(responseStream, Encoding.ASCII)) { //Hack because XmlWriter really wants to add encoding="us-ascii" which segfaults skate 3 await textWriter.WriteAsync("<?xml version=\"1.0\"?>"); using var xmlWriter = XmlWriter.Create(textWriter, _writerSettings); Serialize(xmlSerializer, xmlWriter, value); } response.ContentLength = fileBufferingWriteStream.Length; await fileBufferingWriteStream.DrainBufferAsync(response.Body); } finally { await fileBufferingWriteStream.DisposeAsync(); } }
public Task WriteAsync(OutputFormatterWriteContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var response = context.HttpContext.Response; response.ContentType = CONTENT_TYPE; if (context.Object == null) { // 忘了在哪里看的了,192 好像在 Response.Body 中表示 null response.Body.WriteByte(192); return(Task.CompletedTask); } using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { // 使用 Jil 序列化 JSON.Serialize(context.Object, writer, _options); return(Task.CompletedTask); } }
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context) { var response = context.HttpContext.Response; var contentType = context.HttpContext.Request.Headers["Accept"][0]; if (contentType.Contains("base64", StringComparison.OrdinalIgnoreCase)) { using (var ms = new MemoryStream()) { ProtoBuf.Serializer.Serialize(ms, context.Object); var output = Convert.ToBase64String(ms.ToArray()); using (var writer = context.WriterFactory(response.Body, System.Text.Encoding.UTF8)) { writer.Write(output); return(writer.FlushAsync()); } } } else { ProtoBuf.Serializer.Serialize(response.Body, context.Object); return(Task.FromResult(response)); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { try { _serializeGenericDefinition .MakeGenericMethod(context.ObjectType) .Invoke(null, new[] { context.Object, writer, _options }); } catch (TargetInvocationException exception) { _logger.LogDebug(exception.InnerException, "Exception was occurred during serialization"); ExceptionDispatchInfo.Capture(exception.InnerException).Throw(); } await writer.FlushAsync(); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var response = context.HttpContext.Response; var converters = StateConverters; var converterProviderContext = new StateConverterProviderContext { ObjectType = context.ObjectType }; var selectedConverter = SelectConverter(converterProviderContext, converters); if (selectedConverter == null) { context.HttpContext.Response.StatusCode = StatusCodes.Status406NotAcceptable; return; } var converterContext = new StateConverterContext { HttpContext = context.HttpContext, Object = context.Object, ObjectType = context.ObjectType }; var document = await selectedConverter.ConvertAsync(converterContext); using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { WriteObject(writer, document); await writer.FlushAsync(); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } string callback; if (IsJsonpRequest(context.HttpContext.Request, _callbackQueryParameter, out callback)) { if (!CallbackValidator.IsValid(callback)) { throw new InvalidOperationException($"Callback '{callback}' is invalid!"); } using (var writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) { // the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse" // the typeof check is just to reduce client error noise writer.Write("/**/ typeof " + callback + " === 'function' && " + callback + "("); writer.Flush(); _jsonMediaTypeFormatter.WriteObject(writer, context.Object); writer.Write(");"); await writer.FlushAsync(); } } else { await _jsonMediaTypeFormatter.WriteResponseBodyAsync(context, selectedEncoding); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { var response = context.HttpContext.Response; var contentType = GetNonEmptyString(context.ContentType.Value, response.ContentType, JSONContentType); var encoding = MediaType.GetEncoding(contentType) ?? jsonFormatter.Encoding; if (JSONContentType.Equals(contentType, StringComparison.InvariantCultureIgnoreCase)) { contentType = $"{JSONContentType};charset={encoding.HeaderName}"; } response.ContentType = contentType; if (encoding == jsonFormatter.Encoding || encoding.Equals(jsonFormatter.Encoding)) { var s = response.Body; await jsonFormatter.SerializeAsync(context.Object, s); await s.FlushAsync(); } else { var tw = context.WriterFactory(response.Body, encoding); await jsonFormatter.SerializeAsync(context.Object, tw); await tw.FlushAsync(); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { ArgumentGuard.NotNull(context, nameof(context)); var response = context.HttpContext.Response; response.ContentType = _serializer.ContentType; await using var writer = context.WriterFactory(response.Body, Encoding.UTF8); string responseContent; try { responseContent = SerializeResponse(context.Object, (HttpStatusCode)response.StatusCode); } catch (Exception exception) { var errorDocument = _exceptionHandler.HandleException(exception); responseContent = _serializer.Serialize(errorDocument); response.StatusCode = (int)errorDocument.GetErrorStatusCode(); } var url = context.HttpContext.Request.GetEncodedUrl(); _traceWriter.LogMessage(() => $"Sending {response.StatusCode} response for request at '{url}' with body: <<{responseContent}>>"); await writer.WriteAsync(responseContent); await writer.FlushAsync(); }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } string callback; if (IsJsonpRequest(context.HttpContext.Request, _callbackQueryParameter, out callback)) { if (!CallbackValidator.IsValid(callback)) { throw new InvalidOperationException($"Callback '{callback}' is invalid!"); } using (var writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) { // the /**/ is a specific security mitigation for "Rosetta Flash JSONP abuse" // the typeof check is just to reduce client error noise var str = "/**/ typeof " + callback + " === 'function' && " + callback + "("; str += context.Object + ");"; writer.Write("/**/ typeof " + callback + " === 'function' && " + callback + "("); writer.Flush(); _jsonMediaTypeFormatter.WriteObject(writer, context.Object); writer.Write(");"); await writer.FlushAsync(); } } else { await _jsonMediaTypeFormatter.WriteResponseBodyAsync(context, selectedEncoding); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { response.ContentType = Constants.ContentType; string responseContent; try { responseContent = GetResponseBody(context.Object); } catch (Exception e) { _logger?.LogError(new EventId(), e, "An error ocurred while formatting the response"); responseContent = GetErrorResponse(e); response.StatusCode = 400; } await writer.WriteAsync(responseContent); await writer.FlushAsync(); } }
/// <summary> /// /// </summary> /// <param name="context"></param> /// <param name="selectedEncoding"></param> /// <returns></returns> public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { // Get logger IServiceProvider serviceProvider = context.HttpContext.RequestServices; var logger = serviceProvider.GetService(typeof(ILogger <ToDoItem>)) as ILogger; // Get HTTP response object var response = context.HttpContext.Response; var buffer = new StringBuilder(); // Build the output if (context.Object is IEnumerable <ToDoItem> ) { foreach (var todoItem in (IEnumerable <ToDoItem>)context.Object) { FormatCsv(buffer, todoItem); } } else { FormatCsv(buffer, (ToDoItem)context.Object); } // Write the output using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { return(writer.WriteAsync(buffer.ToString())); } }
/// <inheritdoc /> public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } object obj = context.Object; TextWriter textWriter = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding); try { textWriter.Write(_serializer.Serialize(obj)); await textWriter.FlushAsync(); } finally { textWriter?.Dispose(); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } _logger?.LogInformation("Formatting response as JSONAPI"); var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { response.ContentType = "application/vnd.api+json"; string responseContent; try { responseContent = GetResponseBody(context.Object); } catch (Exception e) { _logger?.LogError(new EventId(), e, "An error ocurred while formatting the response"); var errors = new ErrorCollection(); errors.Add(new Error("400", e.Message)); responseContent = errors.GetJson(); response.StatusCode = 400; } await writer.WriteAsync(responseContent); await writer.FlushAsync(); } }
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { JsonSerializeOption option = null; if (context.Object is JsonResultWrapper wrapper) { option = wrapper.Option; } option = option ?? new JsonSerializeOption(); var globalconverters = GlobalSetting.Converters.Where(s => s is JsonConverter).Cast <JsonConverter>(); option.Converters.AddRange(globalconverters); var serializer = new JsonSerializer(option); using (var jsonWriter = new JsonWriter(writer)) { serializer.Serialize(context.Object, jsonWriter); } } return(Task.CompletedTask); }
public override async Task WriteResponseBodyAsync( OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } using (TextWriter writer = context.WriterFactory( context.HttpContext.Response.Body, selectedEncoding)) { this.WriteObject(writer, new { result = context.Object, resultCode = context.HttpContext.Response.StatusCode, resultMessage = ((HttpStatusCode)context.HttpContext.Response.StatusCode) .ToString() }); await writer.FlushAsync(); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { ArgumentGuard.NotNull(context, nameof(context)); HttpResponse response = context.HttpContext.Response; response.ContentType = _serializer.ContentType; await using TextWriter writer = context.WriterFactory(response.Body, Encoding.UTF8); string responseContent; try { responseContent = SerializeResponse(context.Object, (HttpStatusCode)response.StatusCode); } #pragma warning disable AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException catch (Exception exception) #pragma warning restore AV1210 // Catch a specific exception instead of Exception, SystemException or ApplicationException { ErrorDocument errorDocument = _exceptionHandler.HandleException(exception); responseContent = _serializer.Serialize(errorDocument); response.StatusCode = (int)errorDocument.GetErrorStatusCode(); } string url = context.HttpContext.Request.GetEncodedUrl(); _traceWriter.LogMessage(() => $"Sending {response.StatusCode} response for request at '{url}' with body: <<{responseContent}>>"); await writer.WriteAsync(responseContent); await writer.FlushAsync(); }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var visibility = Visibility.Full; if (context.HttpContext.Items.TryGetValue(VisibilityFilterAttribute.HttpContextItemKey, out var item) && item is VisibilityFilterAttribute attribute) { visibility = attribute.Visibility; } var response = context.HttpContext.Response; await using var writer = context.WriterFactory(response.Body, selectedEncoding); await writer.WriteAsync(JsonConvert.SerializeObject(context.Object, new JsonSerializerSettings() { ContractResolver = new VisibilityContractResolver(visibility), ReferenceLoopHandling = ReferenceLoopHandling.Ignore })); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await writer.FlushAsync(); }
/// <inheritdoc /> public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { Guard.NotNull(context, nameof(context)); Guard.NotNull(selectedEncoding, nameof(selectedEncoding)); //{"result":null,"error":{"code":-32601,"message":"Method not found"},"id":1} var jsonResult = JToken.FromObject(context.Object, this.JsonSerializer); var response = new JObject { ["result"] = jsonResult, ["error"] = null }; using (var textWriter = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) using (var jsonWriter = new JsonTextWriter(textWriter)) { await response.WriteToAsync(jsonWriter); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await textWriter.FlushAsync(); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { EnsureArg.IsNotNull(context, nameof(context)); EnsureArg.IsNotNull(selectedEncoding, nameof(selectedEncoding)); context.HttpContext.AllowSynchronousIO(); var engine = context.HttpContext.RequestServices.GetService <IRazorViewEngine>(); var tempDataProvider = context.HttpContext.RequestServices.GetService <ITempDataProvider>(); var actionContext = new ActionContext(context.HttpContext, context.HttpContext.GetRouteData(), new ActionDescriptor()); using (TextWriter textWriter = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) { var viewName = "ViewJson"; var viewResult = engine.FindView(actionContext, viewName, true); if (viewResult.View == null) { throw new FileNotFoundException(Api.Resources.ViewNotFound, $"{viewName}.cshtml"); } var resourceInstance = (Resource)context.Object; string div = null; if (resourceInstance is DomainResource domainResourceInstance && !string.IsNullOrEmpty(domainResourceInstance.Text?.Div)) { div = _htmlSanitizer.Sanitize(domainResourceInstance.Text.Div); } var stringBuilder = new StringBuilder(); using (var stringWriter = new StringWriter(stringBuilder)) using (var jsonTextWriter = new JsonTextWriter(stringWriter)) { jsonTextWriter.ArrayPool = _charPool; jsonTextWriter.Formatting = Formatting.Indented; _fhirJsonSerializer.Serialize(resourceInstance, jsonTextWriter, context.HttpContext.GetSummaryTypeOrDefault(), context.HttpContext.GetElementsOrDefault()); } var viewDictionary = new ViewDataDictionary(new EmptyModelMetadataProvider(), new ModelStateDictionary()) { Model = new CodePreviewModel { Code = stringBuilder.ToString(), Div = div, }, }; var viewContext = new ViewContext( actionContext, viewResult.View, viewDictionary, new TempDataDictionary(actionContext.HttpContext, tempDataProvider), textWriter, new HtmlHelperOptions()); await viewResult.View.RenderAsync(viewContext); } }
Task IOutputFormatter.WriteAsync(OutputFormatterWriteContext context) { using (var writer = context.WriterFactory(context.HttpContext.Response.Body, Encoding.UTF8)) { EasyJsonSerializer.SerializeObject(context.Object, writer); return(writer.FlushAsync()); } }
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding encoding) { using (var writer = context.WriterFactory(context.HttpContext.Response.Body, encoding)) { Serialize(context.Object, writer); await writer.FlushAsync(); } }
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding encoding) { var xmp = XmpMetaFactory.SerializeToString(context.Object as IXmpMeta, new SerializeOptions()); using (var writer = context.WriterFactory(context.HttpContext.Response.Body, encoding)) { return(writer.WriteAsync(xmp)); } }
public override Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { return(writer.WriteAsync(context.Object.ToString())); } }
private async Task WriteResponse(OutputFormatterWriteContext context, Encoding selectedEncoding, object response) { using (TextWriter writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) { WriteObject(writer, response); await writer.FlushAsync(); } }
private static async Task WriteToBody(OutputFormatterWriteContext context, HttpResponse response, string content) { using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { await writer.WriteAsync(content); await writer.FlushAsync(); } }
public override System.Threading.Tasks.Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { //try //{ if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } if (selectedEncoding != Encoding.UTF8) { //throw Error.BadRequest($"FHIR supports UTF-8 encoding exclusively, not {selectedEncoding.WebName}"); throw new InterneuronBusinessException((short)HttpStatusCode.BadRequest, $"FHIR supports UTF-8 encoding exclusively, not {selectedEncoding.WebName}"); } using (TextWriter writer = context.WriterFactory(context.HttpContext.Response.Body, selectedEncoding)) using (XmlWriter xmlWriter = new XmlTextWriter(writer)) { if (!(context.HttpContext.RequestServices.GetService(typeof(FhirXmlSerializer)) is FhirXmlSerializer serializer)) { //throw Error.Internal($"Missing required dependency '{nameof(FhirXmlSerializer)}'"); throw new InterneuronBusinessException((short)HttpStatusCode.InternalServerError, $"Missing required dependency '{nameof(FhirJsonSerializer)}'"); } SummaryType summaryType = context.HttpContext.Request.RequestSummary(); if (typeof(FhirResponse).IsAssignableFrom(context.ObjectType)) { FhirResponse response = context.Object as FhirResponse; context.HttpContext.Response.StatusCode = (int)response.StatusCode; if (response.Resource != null) { serializer.Serialize(response.Resource, xmlWriter, summaryType); } } else if (context.ObjectType == typeof(OperationOutcome) || typeof(Resource).IsAssignableFrom(context.ObjectType)) { if (context.Object != null) { serializer.Serialize(context.Object as Resource, xmlWriter, summaryType); } } } return(System.Threading.Tasks.Task.CompletedTask); //} //catch(Exception ex) //{ // var x = ex; // return System.Threading.Tasks.Task.CompletedTask; //} }
public Task WriteAsync(OutputFormatterWriteContext context) { var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { writer.Write(context.Object); return(writer.FlushAsync()); } }
public async Task WriteAsync(OutputFormatterWriteContext context) { if (context == null) throw new ArgumentNullException(nameof(context)); var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, Encoding.UTF8)) { var responseJson = SerializationService.SerializeWithRoot(context.Object, _outputPayloadFormatOptions); await writer.WriteAsync(responseJson); await writer.FlushAsync(); } }
/// <inheritdoc /> public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } var response = context.HttpContext.Response; using (var writer = context.WriterFactory(response.Body, selectedEncoding)) { WriteObject(writer, context.Object); // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await writer.FlushAsync(); } }
/// <inheritdoc /> public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (selectedEncoding == null) { throw new ArgumentNullException(nameof(selectedEncoding)); } var writerSettings = WriterSettings.Clone(); writerSettings.Encoding = selectedEncoding; // Wrap the object only if there is a wrapping type. var value = context.Object; var wrappingType = GetSerializableType(context.ObjectType); if (wrappingType != null && wrappingType != context.ObjectType) { var wrapperProvider = WrapperProviderFactories.GetWrapperProvider(new WrapperProviderContext( declaredType: context.ObjectType, isSerialization: true)); value = wrapperProvider.Wrap(value); } var dataContractSerializer = GetCachedSerializer(wrappingType); using (var textWriter = context.WriterFactory(context.HttpContext.Response.Body, writerSettings.Encoding)) { using (var xmlWriter = CreateXmlWriter(textWriter, writerSettings)) { dataContractSerializer.WriteObject(xmlWriter, value); } // Perf: call FlushAsync to call WriteAsync on the stream with any content left in the TextWriter's // buffers. This is better than just letting dispose handle it (which would result in a synchronous // write). await textWriter.FlushAsync(); } }