Use DisposeAsync in FileStreamResultExecutor (#55524)

Author: ascott18

src/Mvc/Mvc.Core/src/Infrastructure/FileStreamResultExecutor.cs

@@ -28,7 +28,7 @@ public virtual async Task ExecuteAsync(ActionContext context, FileStreamResult r
         ArgumentNullException.ThrowIfNull(context);
         ArgumentNullException.ThrowIfNull(result);
 
-        using (result.FileStream)
+        await using (result.FileStream)
         {
             Log.ExecutingFileResult(Logger, result);
 

src/Mvc/Mvc.Core/test/Infrastructure/FileStreamResultExecutorTest.cs

@@ -0,0 +1,70 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.Mvc.Infrastructure;
+
+public class FileStreamResultExecutorTest
+{
+    [Fact]
+    public async Task ExecuteAsync_DisposesStreamAsync()
+    {
+        // Arrange
+        var executor = CreateExecutor();
+
+        var httpContext = new DefaultHttpContext();
+        var actionContext = new ActionContext() { HttpContext = httpContext };
+
+        var stream = new AsyncOnlyStream();
+        var result = new FileStreamResult(stream, "text/plain");
+
+        // Act
+        await executor.ExecuteAsync(actionContext, result);
+
+        // Assert
+        Assert.True(stream.DidDisposeAsync);
+    }
+
+    private static FileStreamResultExecutor CreateExecutor()
+    {
+        return new FileStreamResultExecutor(NullLoggerFactory.Instance);
+    }
+
+    private class AsyncOnlyStream : Stream
+    {
+        public override bool CanRead => true;
+
+        public override bool CanSeek => false;
+
+        public override bool CanWrite => false;
+
+        public override long Length => throw new NotImplementedException();
+
+        public override long Position { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
+
+        public override void Flush() { }
+
+        public override int Read(byte[] buffer, int offset, int count) => throw new NotSupportedException("Must use ReadAsync");
+
+        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            => Task.FromResult(0);
+
+        public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException();
+
+        public override void SetLength(long value) => throw new NotImplementedException();
+
+        public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException();
+
+        protected override void Dispose(bool disposing) => throw new NotSupportedException("Must use DisposeAsync");
+
+        public bool DidDisposeAsync { get; private set; }
+
+        public override ValueTask DisposeAsync()
+        {
+            DidDisposeAsync = true;
+            return ValueTask.CompletedTask;
+        }
+    }
+}

src/Shared/ResultsHelpers/FileResultHelper.cs

@@ -30,7 +30,7 @@ internal static async Task WriteFileAsync(HttpContext context, Stream fileStream
     {
         const int BufferSize = 64 * 1024;
         var outputStream = context.Response.Body;
-        using (fileStream)
+        await using (fileStream)
         {
             try
             {