feat: sample for big-file-upload via MultiPartReader / IPipeReader / IFormFeature (net9) (#35527)

Author: DeagleGross

aspnetcore/mvc/models/file-uploads/samples/9.x/.gitignore

@@ -0,0 +1 @@
+**/*.dat

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/Controllers/FileController.cs

@@ -0,0 +1,77 @@
+using FileManagerSample.Services;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Net.Http.Headers;
+
+namespace FileManagerSample.Controllers
+{
+    [ApiController]
+    [Route("controller")]
+    public class FileController : ControllerBase
+    {
+        public const int BufferSize = 16 * 1024 * 1024; // 16 MB buffer size
+        public const string UploadFilePath = "file-upload.dat";
+
+        private readonly ILogger<FileController> _logger;
+        private readonly FileManagerService _fileManager;
+
+        public FileController(
+            ILogger<FileController> logger,
+            FileManagerService fileManager)
+        {
+            _logger = logger;
+            _fileManager = fileManager;
+        }
+
+        [HttpPost]
+        [Route("multipart")]
+        public async Task<IActionResult> UploadMultipartReader()
+        {
+            if (!Request.ContentType?.StartsWith("multipart/form-data") ?? true)
+            {
+                return BadRequest("The request does not contain valid multipart form data.");
+            }
+
+            var boundary = HeaderUtilities.RemoveQuotes(MediaTypeHeaderValue.Parse(Request.ContentType).Boundary).Value;
+            if (string.IsNullOrWhiteSpace(boundary))
+            {
+                return BadRequest("Missing boundary in multipart form data.");
+            }
+
+            var cancellationToken = HttpContext.RequestAborted;
+            var filePath = await _fileManager.SaveViaMultipartReaderAsync(boundary, Request.Body, cancellationToken);
+            return Ok("Saved file at " + filePath);
+        }
+
+        [HttpPost]
+        [Route("pipe")]
+        public async Task<IActionResult> UploadPipeReader()
+        {
+            if (!Request.HasFormContentType)
+            {
+                return BadRequest("The request does not contain a valid form.");
+            }
+
+            var cancellationToken = HttpContext.RequestAborted;
+            var filePath = await _fileManager.SaveViaPipeReaderAsync(Request.BodyReader, cancellationToken);
+            return Ok("Saved file at " + filePath);
+        }
+
+        [HttpPost]
+        [Route("form")]
+        public async Task<IActionResult> ReadForms()
+        {
+            if (!Request.HasFormContentType)
+            {
+                return BadRequest("The request does not contain a valid form.");
+            }
+
+            var cancellationToken = HttpContext.RequestAborted;
+            var formFeature = Request.HttpContext.Features.GetRequiredFeature<IFormFeature>();
+            await formFeature.ReadFormAsync(cancellationToken);
+
+            var filePath = Request.Form.Files.First().FileName;
+            return Ok("Saved file at " + filePath);
+        }
+    }
+}

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/FileManagerSample.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>net9.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+</Project>

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/Program.cs

@@ -0,0 +1,71 @@
+using FileManagerSample.Services;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.Net.Http.Headers;
+
+var builder = WebApplication.CreateBuilder(args);
+builder.Services.AddSingleton<FileManagerService>();
+
+builder.WebHost.ConfigureKestrel(options =>
+{
+    // if not present, will throw similar exception:
+        //   Microsoft.AspNetCore.Server.Kestrel.Core.BadHttpRequestException: Request body too large. The max request body size is 30000000 bytes.
+    options.Limits.MaxRequestBodySize = 6L * 1024 * 1024 * 1024; // 6 GB
+
+    // optional: timeout settings
+    options.Limits.KeepAliveTimeout = TimeSpan.FromMinutes(10);
+    options.Limits.RequestHeadersTimeout = TimeSpan.FromMinutes(10);
+});
+
+builder.Services.Configure<FormOptions>(options =>
+{
+    options.MultipartBodyLengthLimit = 10L * 1024 * 1024 * 1024; // 10 GB
+});
+
+builder.Services.AddControllers();
+
+var app = builder.Build();
+app.MapControllers();
+
+app.MapPost("minimal/multipart", async (FileManagerService fileManager, HttpRequest request, CancellationToken cancellationToken) =>
+{
+    if (!request.ContentType?.StartsWith("multipart/form-data") ?? true)
+    {
+        return Results.BadRequest("The request does not contain valid multipart form data.");
+    }
+
+    var boundary = HeaderUtilities.RemoveQuotes(MediaTypeHeaderValue.Parse(request.ContentType).Boundary).Value;
+    if (string.IsNullOrWhiteSpace(boundary))
+    {
+        return Results.BadRequest("Missing boundary in multipart form data.");
+    }
+
+    var filePath = await fileManager.SaveViaMultipartReaderAsync(boundary, request.Body, cancellationToken);
+    return Results.Ok("Saved file at " + filePath);
+});
+
+app.MapPost("minimal/pipe", async (FileManagerService fileManager, HttpRequest request, CancellationToken cancellationToken) =>
+{
+    if (!request.HasFormContentType)
+    {
+        return Results.BadRequest("The request does not contain a valid form.");
+    }
+
+    var filePath = await fileManager.SaveViaPipeReaderAsync(request.BodyReader, cancellationToken);
+    return Results.Ok("Saved file at " + filePath);
+});
+
+app.MapPost("minimal/form", async (HttpRequest request, CancellationToken cancellationToken) =>
+{
+    if (!request.HasFormContentType)
+    {
+        return Results.BadRequest("The request does not contain a valid form.");
+    }
+
+    var formFeature = request.HttpContext.Features.GetRequiredFeature<IFormFeature>();
+    await formFeature.ReadFormAsync(cancellationToken);
+
+    var filePath = request.Form.Files.First().FileName;
+    return Results.Ok("Saved file at " + filePath);
+});
+
+app.Run();

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/Services/FileManagerService.cs

@@ -0,0 +1,108 @@
+using System.IO.Pipelines;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Net.Http.Headers;
+
+namespace FileManagerSample.Services
+{
+    public class FileManagerService
+    {
+        private const int BufferSize = 16 * 1024 * 1024; // 16 MB buffer size
+        private const string UploadFilePath = "file-upload.dat";
+
+        private readonly ILogger<FileManagerService> _logger;
+
+        public FileManagerService(ILogger<FileManagerService> logger)
+        {
+            _logger = logger;
+        }
+
+        public async Task<string> SaveViaMultipartReaderAsync(string boundary, Stream contentStream, CancellationToken cancellationToken)
+        {
+            string targetFilePath = Path.Combine(Directory.GetCurrentDirectory(), UploadFilePath);
+            CheckAndRemoveLocalFile(targetFilePath);
+
+            using FileStream outputFileStream = new FileStream(
+                path: targetFilePath,
+                mode: FileMode.Create,
+                access: FileAccess.Write,
+                share: FileShare.None,
+                bufferSize: BufferSize,
+                useAsync: true);
+
+            var reader = new MultipartReader(boundary, contentStream);
+            MultipartSection? section;
+            long totalBytesRead = 0;
+
+            // Process each section in the multipart body
+            while ((section = await reader.ReadNextSectionAsync(cancellationToken)) != null)
+            {
+                // Check if the section is a file
+                var contentDisposition = section.GetContentDispositionHeader();
+                if (contentDisposition != null && contentDisposition.IsFileDisposition())
+                {
+                    _logger.LogInformation($"Processing file: {contentDisposition.FileName.Value}");
+
+                    // Write the file content to the target file
+                    await section.Body.CopyToAsync(outputFileStream, cancellationToken);
+                    totalBytesRead += section.Body.Length;
+                }
+                else if (contentDisposition != null && contentDisposition.IsFormDisposition())
+                {
+                    // Handle metadata (form fields)
+                    string key = contentDisposition.Name.Value!;
+                    using var streamReader = new StreamReader(section.Body);
+                    string value = await streamReader.ReadToEndAsync(cancellationToken);
+                    _logger.LogInformation($"Received metadata: {key} = {value}");
+                }
+            }
+
+            _logger.LogInformation($"File upload completed (via multipart). Total bytes read: {totalBytesRead} bytes.");
+            return targetFilePath;
+        }
+
+        private void CheckAndRemoveLocalFile(string filePath)
+        {
+            if (File.Exists(filePath))
+            {
+                File.Delete(filePath);
+                _logger.LogDebug($"Removed existing output file: {filePath}");
+            }
+        }
+
+        public async Task<string?> SaveViaPipeReaderAsync(PipeReader contentReader, CancellationToken cancellationToken)
+        {
+            string targetFilePath = Path.Combine(Directory.GetCurrentDirectory(), UploadFilePath);
+            CheckAndRemoveLocalFile(targetFilePath);
+            long totalBytesRead = 0;
+
+            using FileStream outputFileStream = new FileStream(
+                path: targetFilePath,
+                mode: FileMode.OpenOrCreate,
+                access: FileAccess.Write,
+                share: FileShare.None,
+                bufferSize: BufferSize,
+                useAsync: true);
+
+            while (true)
+            {
+                var readResult = await contentReader.ReadAsync();
+                var buffer = readResult.Buffer;
+
+                foreach (var memory in buffer)
+                {
+                    await outputFileStream.WriteAsync(memory);
+                    totalBytesRead += memory.Length;
+                }
+                contentReader.AdvanceTo(buffer.End);
+
+                if (readResult.IsCompleted)
+                {
+                    break;
+                }
+            }
+
+            _logger.LogInformation($"File upload completed (via pipeReader). Total bytes read: {totalBytesRead} bytes.");
+            return targetFilePath;
+        }
+    }
+}

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/appsettings.Development.json

@@ -0,0 +1,8 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  }
+}

aspnetcore/mvc/models/file-uploads/samples/9.x/FileManagerSample/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    }
+  },
+  "AllowedHosts": "*"
+}