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