public async Task WriteAsync_AfterMemoryThresholdIsReached_BuffersToMemory()
{
// Arrange
var input = new byte[] { 1, 2, 3, 4, 5, 6, 7 };
using var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 4, tempFileDirectoryAccessor: () => TempDirectory);
// Act
await bufferingStream.WriteAsync(input, 0, 5);
await bufferingStream.WriteAsync(input, 5, 2);
// Assert
var pageBuffer = bufferingStream.PagedByteBuffer;
var fileStream = bufferingStream.FileStream;
// File should have been created.
Assert.NotNull(fileStream);
var fileBytes = ReadFileContent(fileStream !);
Assert.Equal(input.Length, bufferingStream.Length);
Assert.Equal(new byte[] { 1, 2, 3, 4, 5, }, fileBytes);
Assert.Equal(new byte[] { 6, 7 }, ReadBufferedContent(pageBuffer));
}
// GET: Error
public async Task <ActionResult> GetBarCode39Async(String code)
{
Response.ContentType = "image/Jpeg";
//response.Buffer = true;
//response.ExpiresAbsolute = System.DateTime.Now.AddMilliseconds(0);
//response.Expires = 0;
if (!String.IsNullOrEmpty(code))
{
try
{
using (Bitmap img = code.GetCode39(false))
{
img.SetResolution(_dpi, _dpi);
using (FileBufferingWriteStream output = new FileBufferingWriteStream())
{
img.Save(output, ImageFormat.Jpeg);
//output.Seek(0, SeekOrigin.Begin);
await output.DrainBufferAsync(Response.Body);
}
}
}
catch (Exception ex)
{
ApplicationLogging.CreateLogger <PublishedController>().LogError(ex, ex.Message);
}
}
//context.Response.CacheControl = "no-cache";
//context.Response.AppendHeader("Pragma", "No-Cache");
return(new EmptyResult());
}
/// <inheritdoc />
public override async Task SerializeToResponse(RequestExecutionContext context)
{
var fileWriteStream = new FileBufferingWriteStream();
SetStatusAndContent(context, _contentType);
try
{
using var textWriter = new StreamWriter(fileWriteStream);
using var xmlWriter = new XmlTextWriter(textWriter);
var serializer = GetSerializer(context.Result.GetType());
serializer.Serialize(xmlWriter, context.Result);
xmlWriter.Flush();
textWriter.Flush();
await fileWriteStream.DrainBufferAsync(context.HttpContext.Response.Body, context.HttpContext.RequestAborted);
}
finally
{
await fileWriteStream.DisposeAsync();
}
}
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();
}
}
/// <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));
}
// Compat mode for derived options
_jsonOptions ??= context.HttpContext.RequestServices.GetRequiredService <IOptions <MvcNewtonsoftJsonOptions> >().Value;
var response = context.HttpContext.Response;
var responseStream = response.Body;
FileBufferingWriteStream?fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream(_jsonOptions.OutputFormatterMemoryBufferThreshold);
responseStream = fileBufferingWriteStream;
}
var value = context.Object;
if (value is not null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
{
_logger ??= context.HttpContext.RequestServices.GetRequiredService <ILogger <NewtonsoftJsonOutputFormatter> >();
Log.BufferingAsyncEnumerable(_logger, value);
value = await reader(value);
}
try
{
await using (var writer = context.WriterFactory(responseStream, selectedEncoding))
{
using var jsonWriter = CreateJsonWriter(writer);
var jsonSerializer = CreateJsonSerializer(context);
jsonSerializer.Serialize(jsonWriter, value);
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.BodyWriter);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
public async Task WriteAsync <T>(Stream stream, T value, CancellationToken cancellationToken = default)
{
await using (var buffer = new FileBufferingWriteStream())
{
jsonSerializer.Serialize(value, buffer, true);
await buffer.DrainBufferAsync(stream, cancellationToken);
}
}
public async Task WriteAsync <T>(Stream stream, T value,
CancellationToken cancellationToken = default)
{
await using (var bufferStream = new FileBufferingWriteStream())
{
await documentWriter.WriteAsync(bufferStream, value, cancellationToken);
await bufferStream.DrainBufferAsync(stream, cancellationToken);
}
}
public async Task <ActionResult> GetQRCodeAsync(String text, QRCodeEncoder.ENCODE_MODE?enc, int?scale, int?ver, QRCodeEncoder.ERROR_CORRECTION?ec, float?dpi)
{
Response.ContentType = "image/Jpeg";
//response.Buffer = true;
//response.ExpiresAbsolute = System.DateTime.Now.AddMilliseconds(0);
//response.Expires = 0;
if (!enc.HasValue)
{
enc = QRCodeEncoder.ENCODE_MODE.BYTE;
}
if (!scale.HasValue)
{
scale = 4;
}
if (!ver.HasValue)
{
ver = 6;
}
if (!ec.HasValue)
{
ec = QRCodeEncoder.ERROR_CORRECTION.L;
}
if (!dpi.HasValue)
{
dpi = 600f;
}
try
{
using (Bitmap img = text.CreateQRCode(enc.Value, scale.Value, ver.Value, ec.Value))
{
img.SetResolution(_dpi, _dpi);
using (FileBufferingWriteStream output = new FileBufferingWriteStream())
{
img.Save(output, ImageFormat.Jpeg);
//output.Seek(0, SeekOrigin.Begin);
await output.DrainBufferAsync(Response.Body);
}
}
}
catch (Exception ex)
{
ApplicationLogging.CreateLogger <PublishedController>().LogError(ex, ex.Message);
}
//context.Response.CacheControl = "no-cache";
//context.Response.AppendHeader("Pragma", "No-Cache");
return(new EmptyResult());
}
public void FileBufferWriteStreamFromAspNetCore()
{
using var writer = new FileBufferingWriteStream(memoryThreshold: MemoryThreshold);
foreach (var chunk in GetChunks())
{
writer.Write(chunk.Span);
}
writer.Flush();
using var ms = new MemoryStream(content.Length);
writer.DrainBufferAsync(ms).GetAwaiter().GetResult();
}
public async Task FileBufferWriteStreamFromAspNetCoreAsync()
{
using var writer = new FileBufferingWriteStream(memoryThreshold: MemoryThreshold);
foreach (var chunk in GetChunks())
{
await writer.WriteAsync(chunk);
}
await writer.FlushAsync();
using var ms = new MemoryStream(content.Length);
await writer.DrainBufferAsync(ms);
}
public async Task WriteAsync_Throws_IfSingleWriteExceedsBufferLimit()
{
// Arrange
var input = new byte[20];
var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 2, bufferLimit: 10, tempFileDirectoryAccessor: () => TempDirectory);
// Act
var exception = await Assert.ThrowsAsync <IOException>(() => bufferingStream.WriteAsync(input, 0, input.Length));
Assert.Equal("Buffer limit exceeded.", exception.Message);
Assert.True(bufferingStream.Disposed);
}
public void Write_DoesNotThrow_IfBufferLimitIsReached()
{
// Arrange
var input = new byte[5];
using var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 2, bufferLimit: 10, tempFileDirectoryAccessor: () => TempDirectory);
// Act
bufferingStream.Write(input, 0, input.Length);
bufferingStream.Write(input, 0, input.Length); // Should get to exactly the buffer limit, which is fine
// If we got here, the test succeeded.
}
public void Write_Throws_IfWriteCumulativeWritesExceedsBuffersLimit()
{
// Arrange
var input = new byte[6];
var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 2, bufferLimit: 10, tempFileDirectoryAccessor: () => TempDirectory);
// Act
bufferingStream.Write(input, 0, input.Length);
var exception = Assert.Throws <IOException>(() => bufferingStream.Write(input, 0, input.Length));
Assert.Equal("Buffer limit exceeded.", exception.Message);
// Verify we return the buffer.
Assert.True(bufferingStream.Disposed);
}
/// <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;
var responseStream = response.Body;
FileBufferingWriteStream fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var writer = context.WriterFactory(responseStream, selectedEncoding))
{
using (var jsonWriter = CreateJsonWriter(writer))
{
var jsonSerializer = CreateJsonSerializer(context);
jsonSerializer.Serialize(jsonWriter, context.Object);
}
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
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;
}
}
var responseStream = response.Body;
FileBufferingWriteStream fileBufferingWriteStream = null;
if (!this.mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var writer = context.WriterFactory(responseStream, selectedEncoding))
{
this.WriteObject(writer, context.Object, fieldsParserResult);
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
public async Task DrainBufferAsync_CopiesContentFromMemoryStream()
{
// Arrange
var input = new byte[] { 1, 2, 3, 4, 5 };
using var bufferingStream = new FileBufferingWriteStream(tempFileDirectoryAccessor: () => TempDirectory);
bufferingStream.Write(input, 0, input.Length);
var memoryStream = new MemoryStream();
// Act
await bufferingStream.DrainBufferAsync(memoryStream, default);
// Assert
Assert.Equal(input, memoryStream.ToArray());
Assert.Equal(0, bufferingStream.Length);
}
public async Task DrainBufferAsync_WithContentInDisk_CopiesContentFromMemoryStream()
{
// Arrange
var input = Enumerable.Repeat((byte)0xca, 30).ToArray();
using var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 21, tempFileDirectoryAccessor: () => TempDirectory);
bufferingStream.Write(input, 0, input.Length);
var memoryStream = new MemoryStream();
// Act
await bufferingStream.DrainBufferAsync(memoryStream, default);
// Assert
Assert.Equal(input, memoryStream.ToArray());
Assert.Equal(0, bufferingStream.Length);
}
public async Task <ActionResult> DrawAllowanceAsync(InvoiceQueryViewModel viewModel)
{
String viewUrl = $"{Startup.Properties["HostDomain"]}{VirtualPathUtility.ToAbsolute("~/Invoice/CanvasPrintAllowance")}{Request.QueryString}";
var converter = new HtmlConverter();
var bytes = converter.FromUrl(viewUrl);
Response.ContentType = "image/jpeg";
using (FileBufferingWriteStream output = new FileBufferingWriteStream())
{
output.Write(bytes);
//output.Seek(0, SeekOrigin.Begin);
await output.DrainBufferAsync(Response.Body);
}
return(new EmptyResult());
}
public async Task WriteAsync_BuffersContentToMemory()
{
// Arrange
using var bufferingStream = new FileBufferingWriteStream(tempFileDirectoryAccessor: () => TempDirectory);
var input = Encoding.UTF8.GetBytes("Hello world");
// Act
await bufferingStream.WriteAsync(input, 0, input.Length);
// Assert
// We should have written content to memory
var pagedByteBuffer = bufferingStream.PagedByteBuffer;
Assert.Equal(input, ReadBufferedContent(pagedByteBuffer));
// No files should not have been created.
Assert.Null(bufferingStream.FileStream);
}
public async Task WriteAsync_BeforeMemoryThresholdIsReached_WritesToMemory()
{
// Arrange
var input = new byte[] { 1, 2, };
using var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 2, tempFileDirectoryAccessor: () => TempDirectory);
// Act
await bufferingStream.WriteAsync(input, 0, 2);
// Assert
var pageBuffer = bufferingStream.PagedByteBuffer;
var fileStream = bufferingStream.FileStream;
// File should have been created.
Assert.Null(fileStream);
// No content should be in the memory stream
Assert.Equal(2, pageBuffer.Length);
Assert.Equal(input, ReadBufferedContent(pageBuffer));
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context, Encoding selectedEncoding)
{
EnsureArg.IsNotNull(context, nameof(context));
EnsureArg.IsNotNull(selectedEncoding, nameof(selectedEncoding));
HttpResponse response = context.HttpContext.Response;
await using var fileBufferingWriteStream = new FileBufferingWriteStream();
await using (TextWriter textWriter = context.WriterFactory(fileBufferingWriteStream, selectedEncoding))
{
using (var jsonWriter = CreateJsonWriter(textWriter))
{
_jsonSerializer.Serialize(jsonWriter, context.Object);
await jsonWriter.FlushAsync();
}
}
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
public override async Task WriteResponseBodyAsync(OutputFormatterWriteContext context)
{
var response = context.HttpContext.Response;
var writeStream = response.Body;
FileBufferingWriteStream?fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
writeStream = fileBufferingWriteStream = new FileBufferingWriteStream();
}
await using (fileBufferingWriteStream)
{
ApiContractSerializer.ProtoBuf.Serialize(writeStream, context.Object, context.ObjectType);
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
}
public void Write_BuffersContentToDisk_WhenWriteWillOverflowMemoryThreshold()
{
// Arrange
var input = new byte[] { 1, 2, 3, };
using var bufferingStream = new FileBufferingWriteStream(memoryThreshold: 2, tempFileDirectoryAccessor: () => TempDirectory);
// Act
bufferingStream.Write(input, 0, input.Length);
// Assert
var pageBuffer = bufferingStream.PagedByteBuffer;
var fileStream = bufferingStream.FileStream;
// File should have been created.
Assert.NotNull(fileStream);
var fileBytes = ReadFileContent(fileStream !);
Assert.Equal(input, fileBytes);
// No content should be in the memory stream
Assert.Equal(0, pageBuffer.Length);
}
public async Task <ActionResult> GetResourceAsync(int id, bool?stretch = false)
{
var item = models.GetTable <Attachment>().Where(a => a.AttachmentID == id).FirstOrDefault();
if (item != null)
{
if (System.IO.File.Exists(item.StoredPath))
{
if (stretch == true)
{
using (Bitmap img = new Bitmap(item.StoredPath))
{
checkOrientation(img);
if (img.Width > Startup.Properties.GetValue <int>("ResourceMaxWidth"))
{
using (Bitmap m = new Bitmap(img, new Size(Startup.Properties.GetValue <int>("ResourceMaxWidth"), img.Height * Startup.Properties.GetValue <int>("ResourceMaxWidth") / img.Width)))
{
Response.ContentType = "image/jpeg";
using (FileBufferingWriteStream output = new FileBufferingWriteStream())
{
m.Save(output, ImageFormat.Jpeg);
//output.Seek(0, SeekOrigin.Begin);
await output.DrainBufferAsync(Response.Body);
}
return(new EmptyResult());
}
}
}
}
return(new PhysicalFileResult(item.StoredPath, "application/octet-stream"));
}
}
return(new EmptyResult());
}
public virtual async Task ExecuteAsync(ActionContext context, ViewComponentResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var response = context.HttpContext.Response;
var viewData = result.ViewData;
if (viewData == null)
{
viewData = new ViewDataDictionary(_modelMetadataProvider, context.ModelState);
}
var tempData = result.TempData;
if (tempData == null)
{
tempData = _tempDataDictionaryFactory.GetTempData(context.HttpContext);
}
ResponseContentTypeHelper.ResolveContentTypeAndEncoding(
result.ContentType,
response.ContentType,
(ViewExecutor.DefaultContentType, Encoding.UTF8),
MediaType.GetEncoding,
out var resolvedContentType,
out var resolvedContentTypeEncoding);
response.ContentType = resolvedContentType;
if (result.StatusCode != null)
{
response.StatusCode = result.StatusCode.Value;
}
await using var writer = _writerFactory.CreateWriter(response.Body, resolvedContentTypeEncoding);
var viewContext = new ViewContext(
context,
NullView.Instance,
viewData,
tempData,
writer,
_htmlHelperOptions);
OnExecuting(viewContext);
// IViewComponentHelper is stateful, we want to make sure to retrieve it every time we need it.
var viewComponentHelper = context.HttpContext.RequestServices.GetRequiredService <IViewComponentHelper>();
(viewComponentHelper as IViewContextAware)?.Contextualize(viewContext);
var viewComponentResult = await GetViewComponentResult(viewComponentHelper, _logger, result);
if (viewComponentResult is ViewBuffer viewBuffer)
{
// In the ordinary case, DefaultViewComponentHelper will return an instance of ViewBuffer. We can simply
// invoke WriteToAsync on it.
await viewBuffer.WriteToAsync(writer, _htmlEncoder);
await writer.FlushAsync();
}
else
{
await using var bufferingStream = new FileBufferingWriteStream();
await using (var intermediateWriter = _writerFactory.CreateWriter(bufferingStream, resolvedContentTypeEncoding))
{
viewComponentResult.WriteTo(intermediateWriter, _htmlEncoder);
}
await bufferingStream.DrainBufferAsync(response.Body);
}
}
public async Task <ActionResult> CaptchaImgAsync(String code)
{
string captcha = code;
Response.ContentType = "image/Png";
using (Bitmap bmp = new Bitmap(120, 30))
{
int x1 = 0;
int y1 = 0;
int x2 = 0;
int y2 = 0;
int x3 = 0;
int y3 = 0;
int intNoiseWidth = 25;
int intNoiseHeight = 15;
Random rdn = new Random();
using (Graphics g = Graphics.FromImage(bmp))
{
//設定字型
using (Font font = new Font("Courier New", 16, FontStyle.Bold))
{
//設定圖片背景
g.Clear(Color.CadetBlue);
//產生雜點
for (int i = 0; i < 100; i++)
{
x1 = rdn.Next(0, bmp.Width);
y1 = rdn.Next(0, bmp.Height);
bmp.SetPixel(x1, y1, Color.DarkGreen);
}
using (Pen pen = new Pen(Brushes.Gray))
{
//產生擾亂弧線
for (int i = 0; i < 15; i++)
{
x1 = rdn.Next(bmp.Width - intNoiseWidth);
y1 = rdn.Next(bmp.Height - intNoiseHeight);
x2 = rdn.Next(1, intNoiseWidth);
y2 = rdn.Next(1, intNoiseHeight);
x3 = rdn.Next(0, 45);
y3 = rdn.Next(-270, 270);
g.DrawArc(pen, x1, y1, x2, y2, x3, y3);
}
}
//把GenPassword()方法換成你自己的密碼產生器，記得把產生出來的密碼存起來日後才能與user的輸入做比較。
g.DrawString(captcha, font, Brushes.Black, 3, 3);
Response.ContentType = "image/Png";
using (FileBufferingWriteStream output = new FileBufferingWriteStream())
{
bmp.Save(output, ImageFormat.Png);
////output.Seek(0, SeekOrigin.Begin);
await output.DrainBufferAsync(Response.Body);
//await output.CopyToAsync(Response.Body);
}
//context.Response.End();
}
}
}
return(new EmptyResult());
}
/// <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;
var httpContext = context.HttpContext;
var response = httpContext.Response;
_mvcOptions ??= httpContext.RequestServices.GetRequiredService <IOptions <MvcOptions> >().Value;
_asyncEnumerableReaderFactory ??= new AsyncEnumerableReader(_mvcOptions);
var value = context.Object;
var valueType = context.ObjectType !;
if (value is not null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
{
Log.BufferingAsyncEnumerable(_logger, value);
value = await reader(value);
valueType = value.GetType();
}
// Wrap the object only if there is a wrapping type.
var wrappingType = GetSerializableType(valueType);
if (wrappingType != null && wrappingType != valueType)
{
var wrapperProvider = WrapperProviderFactories.GetWrapperProvider(new WrapperProviderContext(
declaredType: valueType,
isSerialization: true));
Debug.Assert(wrapperProvider is not null);
value = wrapperProvider.Wrap(value);
}
var xmlSerializer = GetCachedSerializer(wrappingType !);
var responseStream = response.Body;
FileBufferingWriteStream?fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var textWriter = context.WriterFactory(responseStream, selectedEncoding))
{
using var xmlWriter = CreateXmlWriter(context, textWriter, writerSettings);
Serialize(xmlSerializer, xmlWriter, value);
}
if (fileBufferingWriteStream != null)
{
response.ContentLength = fileBufferingWriteStream.Length;
await fileBufferingWriteStream.DrainBufferAsync(response.BodyWriter);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
/// <summary>
/// Executes the <see cref="JsonResult"/> and writes the response.
/// </summary>
/// <param name="context">The <see cref="ActionContext"/>.</param>
/// <param name="result">The <see cref="JsonResult"/>.</param>
/// <returns>A <see cref="Task"/> which will complete when writing has completed.</returns>
public async Task ExecuteAsync(ActionContext context, JsonResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var jsonSerializerSettings = GetSerializerSettings(result);
var response = context.HttpContext.Response;
ResponseContentTypeHelper.ResolveContentTypeAndEncoding(
result.ContentType,
response.ContentType,
DefaultContentType,
out var resolvedContentType,
out var resolvedContentTypeEncoding);
response.ContentType = resolvedContentType;
if (result.StatusCode != null)
{
response.StatusCode = result.StatusCode.Value;
}
Log.JsonResultExecuting(_logger, result.Value);
var responseStream = response.Body;
FileBufferingWriteStream?fileBufferingWriteStream = null;
if (!_mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var writer = _writerFactory.CreateWriter(responseStream, resolvedContentTypeEncoding))
{
using var jsonWriter = new JsonTextWriter(writer);
jsonWriter.ArrayPool = _charPool;
jsonWriter.CloseOutput = false;
jsonWriter.AutoCompleteOnClose = false;
var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings);
var value = result.Value;
if (value != null && _asyncEnumerableReaderFactory.TryGetReader(value.GetType(), out var reader))
{
Log.BufferingAsyncEnumerable(_logger, value);
value = await reader(value);
}
jsonSerializer.Serialize(jsonWriter, value);
}
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
/// <summary>
/// Executes the <see cref="PartialJsonResult"/> and writes the response.
/// </summary>
/// <param name="context">The <see cref="ActionContext"/>.</param>
/// <param name="result">The <see cref="PartialJsonResult"/>.</param>
/// <returns>A <see cref="Task"/> which will complete when writing has completed.</returns>
public async Task ExecuteAsync(ActionContext context, PartialJsonResult result)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
var jsonSerializerSettings = this.GetSerializerSettings(result);
var request = context.HttpContext.Request;
var response = context.HttpContext.Response;
var fieldsParserResult = this.fieldsParser.Parse(request);
if (fieldsParserResult.HasError && !this.jsonOptions.IgnoreParseErrors)
{
response.StatusCode = 400;
return;
}
ResponseContentTypeHelper.ResolveContentTypeAndEncoding(result.ContentType, response.ContentType, DefaultContentType, out var resolvedContentType, out var resolvedContentTypeEncoding);
response.ContentType = resolvedContentType;
if (result.StatusCode != null)
{
response.StatusCode = result.StatusCode.Value;
}
Log.PartialJsonResultExecuting(this.logger, result.Value);
var responseStream = response.Body;
FileBufferingWriteStream fileBufferingWriteStream = null;
if (!this.mvcOptions.SuppressOutputFormatterBuffering)
{
fileBufferingWriteStream = new FileBufferingWriteStream();
responseStream = fileBufferingWriteStream;
}
try
{
await using (var writer = this.writerFactory.CreateWriter(responseStream, resolvedContentTypeEncoding))
{
using var jsonWriter = new JsonTextWriter(writer);
jsonWriter.ArrayPool = this.charPool;
jsonWriter.CloseOutput = false;
jsonWriter.AutoCompleteOnClose = false;
var jsonSerializer = JsonSerializer.Create(jsonSerializerSettings);
var value = result.Value;
if (result.Value is IAsyncEnumerable <object> asyncEnumerable)
{
Log.BufferingAsyncEnumerable(this.logger, asyncEnumerable);
value = await this.asyncEnumerableReader.ReadAsync(asyncEnumerable);
}
if (fieldsParserResult.IsFieldsSet && !fieldsParserResult.HasError)
{
jsonSerializer.Serialize(jsonWriter, result.Value, path => fieldsParserResult.Fields.Matches(path, this.jsonOptions.IgnoreCase));
}
else
{
jsonSerializer.Serialize(jsonWriter, result.Value);
}
}
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DrainBufferAsync(response.Body);
}
}
finally
{
if (fileBufferingWriteStream != null)
{
await fileBufferingWriteStream.DisposeAsync();
}
}
}
