Use FileOptions.Asynchronous when doing async IO

src/ImageSharp/IO/IFileSystem.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.IO;
@@ -9,16 +9,32 @@ namespace SixLabors.ImageSharp.IO;
 internal interface IFileSystem
 {
     /// <summary>
-    /// Returns a readable stream as defined by the path.
+    /// Opens a file as defined by the path and returns it as a readable stream.
     /// </summary>
     /// <param name="path">Path to the file to open.</param>
-    /// <returns>A stream representing the file to open.</returns>
+    /// <returns>A stream representing the opened file.</returns>
     Stream OpenRead(string path);
 
     /// <summary>
-    /// Creates or opens a file and returns it as a writable stream as defined by the path.
+    /// Opens a file as defined by the path and returns it as a readable stream
+    /// that can be used for asynchronous reading.
     /// </summary>
     /// <param name="path">Path to the file to open.</param>
-    /// <returns>A stream representing the file to open.</returns>
+    /// <returns>A stream representing the opened file.</returns>
+    Stream OpenReadAsynchronous(string path);
+
+    /// <summary>
+    /// Creates or opens a file as defined by the path and returns it as a writable stream.
+    /// </summary>
+    /// <param name="path">Path to the file to open.</param>
+    /// <returns>A stream representing the opened file.</returns>
     Stream Create(string path);
+
+    /// <summary>
+    /// Creates or opens a file as defined by the path and returns it as a writable stream
+    /// that can be used for asynchronous reading and writing.
+    /// </summary>
+    /// <param name="path">Path to the file to open.</param>
+    /// <returns>A stream representing the opened file.</returns>
+    Stream CreateAsynchronous(string path);
 }

src/ImageSharp/IO/LocalFileSystem.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 namespace SixLabors.ImageSharp.IO;
@@ -11,6 +11,24 @@ internal sealed class LocalFileSystem : IFileSystem
     /// <inheritdoc/>
     public Stream OpenRead(string path) => File.OpenRead(path);
 
+    /// <inheritdoc/>
+    public Stream OpenReadAsynchronous(string path) => File.Open(path, new FileStreamOptions
+    {
+        Mode = FileMode.Open,
+        Access = FileAccess.Read,
+        Share = FileShare.Read,
+        Options = FileOptions.Asynchronous,
+    });
+
     /// <inheritdoc/>
     public Stream Create(string path) => File.Create(path);
+
+    /// <inheritdoc/>
+    public Stream CreateAsynchronous(string path) => File.Open(path, new FileStreamOptions
+    {
+        Mode = FileMode.Create,
+        Access = FileAccess.ReadWrite,
+        Share = FileShare.None,
+        Options = FileOptions.Asynchronous,
+    });
 }

src/ImageSharp/Image.FromFile.cs

@@ -72,7 +72,7 @@ public static async Task<IImageFormat> DetectFormatAsync(
     {
         Guard.NotNull(options, nameof(options));
 
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await DetectFormatAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -144,7 +144,7 @@ public static async Task<ImageInfo> IdentifyAsync(
         CancellationToken cancellationToken = default)
     {
         Guard.NotNull(options, nameof(options));
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await IdentifyAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -214,7 +214,7 @@ public static async Task<Image> LoadAsync(
         string path,
         CancellationToken cancellationToken = default)
     {
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await LoadAsync(options, stream, cancellationToken).ConfigureAwait(false);
     }
 
@@ -291,7 +291,7 @@ public static async Task<Image<TPixel>> LoadAsync<TPixel>(
         Guard.NotNull(options, nameof(options));
         Guard.NotNull(path, nameof(path));
 
-        using Stream stream = options.Configuration.FileSystem.OpenRead(path);
+        await using Stream stream = options.Configuration.FileSystem.OpenReadAsynchronous(path);
         return await LoadAsync<TPixel>(options, stream, cancellationToken).ConfigureAwait(false);
     }
 }

src/ImageSharp/ImageExtensions.cs

@@ -70,7 +70,7 @@ public static async Task SaveAsync(
         Guard.NotNull(path, nameof(path));
         Guard.NotNull(encoder, nameof(encoder));
 
-        using Stream fs = source.GetConfiguration().FileSystem.Create(path);
+        await using Stream fs = source.GetConfiguration().FileSystem.CreateAsynchronous(path);
         await source.SaveAsync(fs, encoder, cancellationToken).ConfigureAwait(false);
     }
 

tests/ImageSharp.Tests/IO/LocalFileSystemTests.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
 using SixLabors.ImageSharp.IO;
@@ -11,36 +11,113 @@ public class LocalFileSystemTests
     public void OpenRead()
     {
         string path = Path.GetTempFileName();
-        string testData = Guid.NewGuid().ToString();
-        File.WriteAllText(path, testData);
+        try
+        {
+            string testData = Guid.NewGuid().ToString();
+            File.WriteAllText(path, testData);
 
-        var fs = new LocalFileSystem();
+            LocalFileSystem fs = new();
 
-        using (var r = new StreamReader(fs.OpenRead(path)))
-        {
-            string data = r.ReadToEnd();
+            using (FileStream stream = (FileStream)fs.OpenRead(path))
+            using (StreamReader reader = new(stream))
+            {
+                Assert.False(stream.IsAsync);
+                Assert.True(stream.CanRead);
+                Assert.False(stream.CanWrite);
 
-            Assert.Equal(testData, data);
+                string data = reader.ReadToEnd();
+
+                Assert.Equal(testData, data);
+            }
         }
+        finally
+        {
+            File.Delete(path);
+        }
+    }
 
-        File.Delete(path);
+    [Fact]
+    public async Task OpenReadAsynchronous()
+    {
+        string path = Path.GetTempFileName();
+        try
+        {
+            string testData = Guid.NewGuid().ToString();
+            File.WriteAllText(path, testData);
+
+            LocalFileSystem fs = new();
+
+            await using (FileStream stream = (FileStream)fs.OpenReadAsynchronous(path))
+            using (StreamReader reader = new(stream))
+            {
+                Assert.True(stream.IsAsync);
+                Assert.True(stream.CanRead);
+                Assert.False(stream.CanWrite);
+
+                string data = await reader.ReadToEndAsync();
+
+                Assert.Equal(testData, data);
+            }
+        }
+        finally
+        {
+            File.Delete(path);
+        }
     }
 
     [Fact]
     public void Create()
     {
         string path = Path.GetTempFileName();
-        string testData = Guid.NewGuid().ToString();
-        var fs = new LocalFileSystem();
+        try
+        {
+            string testData = Guid.NewGuid().ToString();
+            LocalFileSystem fs = new();
+
+            using (FileStream stream = (FileStream)fs.Create(path))
+            using (StreamWriter writer = new(stream))
+            {
+                Assert.False(stream.IsAsync);
+                Assert.True(stream.CanRead);
+                Assert.True(stream.CanWrite);
 
-        using (var r = new StreamWriter(fs.Create(path)))
+                writer.Write(testData);
+            }
+
+            string data = File.ReadAllText(path);
+            Assert.Equal(testData, data);
+        }
+        finally
         {
-            r.Write(testData);
+            File.Delete(path);
         }
+    }
 
-        string data = File.ReadAllText(path);
-        Assert.Equal(testData, data);
+    [Fact]
+    public async Task CreateAsynchronous()
+    {
+        string path = Path.GetTempFileName();
+        try
+        {
+            string testData = Guid.NewGuid().ToString();
+            LocalFileSystem fs = new();
+
+            await using (FileStream stream = (FileStream)fs.CreateAsynchronous(path))
+            await using (StreamWriter writer = new(stream))
+            {
+                Assert.True(stream.IsAsync);
+                Assert.True(stream.CanRead);
+                Assert.True(stream.CanWrite);
+
+                await writer.WriteAsync(testData);
+            }
 
-        File.Delete(path);
+            string data = File.ReadAllText(path);
+            Assert.Equal(testData, data);
+        }
+        finally
+        {
+            File.Delete(path);
+        }
     }
 }

tests/ImageSharp.Tests/Image/ImageSaveTests.cs

@@ -44,7 +44,7 @@ public ImageSaveTests()
     [Fact]
     public void SavePath()
     {
-        var stream = new MemoryStream();
+        using MemoryStream stream = new();
         this.fileSystem.Setup(x => x.Create("path.png")).Returns(stream);
         this.image.Save("path.png");
 
@@ -54,7 +54,7 @@ public void SavePath()
     [Fact]
     public void SavePathWithEncoder()
     {
-        var stream = new MemoryStream();
+        using MemoryStream stream = new();
         this.fileSystem.Setup(x => x.Create("path.jpg")).Returns(stream);
 
         this.image.Save("path.jpg", this.encoderNotInFormat.Object);
@@ -73,7 +73,7 @@ public void ToBase64String()
     [Fact]
     public void SaveStreamWithMime()
     {
-        var stream = new MemoryStream();
+        using MemoryStream stream = new();
         this.image.Save(stream, this.localImageFormat.Object);
 
         this.encoder.Verify(x => x.Encode(this.image, stream));
@@ -82,7 +82,7 @@ public void SaveStreamWithMime()
     [Fact]
     public void SaveStreamWithEncoder()
     {
-        var stream = new MemoryStream();
+        using MemoryStream stream = new();
 
         this.image.Save(stream, this.encoderNotInFormat.Object);
 

tests/ImageSharp.Tests/Image/ImageTests.ImageLoadTestBase.cs

@@ -122,6 +122,7 @@ protected ImageLoadTestBase()
             Stream StreamFactory() => this.DataStream;
 
             this.LocalFileSystemMock.Setup(x => x.OpenRead(this.MockFilePath)).Returns(StreamFactory);
+            this.LocalFileSystemMock.Setup(x => x.OpenReadAsynchronous(this.MockFilePath)).Returns(StreamFactory);
             this.topLevelFileSystem.AddFile(this.MockFilePath, StreamFactory);
             this.LocalConfiguration.FileSystem = this.LocalFileSystemMock.Object;
             this.TopLevelConfiguration.FileSystem = this.topLevelFileSystem;
@@ -132,6 +133,11 @@ public void Dispose()
             // Clean up the global object;
             this.localStreamReturnImageRgba32?.Dispose();
             this.localStreamReturnImageAgnostic?.Dispose();
+
+            if (this.dataStreamLazy.IsValueCreated)
+            {
+                this.dataStreamLazy.Value.Dispose();
+            }
         }
 
         protected virtual Stream CreateStream() => this.TestFormat.CreateStream(this.Marker);

tests/ImageSharp.Tests/TestFileSystem.cs

@@ -1,14 +1,16 @@
-// Copyright (c) Six Labors.
+// Copyright (c) Six Labors.
 // Licensed under the Six Labors Split License.
 
+#nullable enable
+
 namespace SixLabors.ImageSharp.Tests;
 
 /// <summary>
 /// A test image file.
 /// </summary>
 public class TestFileSystem : ImageSharp.IO.IFileSystem
 {
-    private readonly Dictionary<string, Func<Stream>> fileSystem = new Dictionary<string, Func<Stream>>(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, Func<Stream>> fileSystem = new(StringComparer.OrdinalIgnoreCase);
 
     public void AddFile(string path, Func<Stream> data)
     {
@@ -18,35 +20,39 @@ public void AddFile(string path, Func<Stream> data)
         }
     }
 
-    public Stream Create(string path)
+    public Stream Create(string path) => this.GetStream(path) ?? File.Create(path);
+
+    public Stream CreateAsynchronous(string path) => this.GetStream(path) ?? File.Open(path, new FileStreamOptions
     {
-        // if we have injected a fake file use it instead
-        lock (this.fileSystem)
-        {
-            if (this.fileSystem.ContainsKey(path))
-            {
-                Stream stream = this.fileSystem[path]();
-                stream.Position = 0;
-                return stream;
-            }
-        }
+        Mode = FileMode.Create,
+        Access = FileAccess.ReadWrite,
+        Share = FileShare.None,
+        Options = FileOptions.Asynchronous,
+    });
 
-        return File.Create(path);
-    }
+    public Stream OpenRead(string path) => this.GetStream(path) ?? File.OpenRead(path);
+
+    public Stream OpenReadAsynchronous(string path) => this.GetStream(path) ?? File.Open(path, new FileStreamOptions
+    {
+        Mode = FileMode.Open,
+        Access = FileAccess.Read,
+        Share = FileShare.Read,
+        Options = FileOptions.Asynchronous,
+    });
 
-    public Stream OpenRead(string path)
+    private Stream? GetStream(string path)
     {
         // if we have injected a fake file use it instead
         lock (this.fileSystem)
         {
-            if (this.fileSystem.ContainsKey(path))
+            if (this.fileSystem.TryGetValue(path, out Func<Stream>? streamFactory))
             {
-                Stream stream = this.fileSystem[path]();
+                Stream stream = streamFactory();
                 stream.Position = 0;
                 return stream;
             }
         }
 
-        return File.OpenRead(path);
+        return null;
     }
 }

tests/ImageSharp.Tests/TestUtilities/SingleStreamFileSystem.cs

@@ -13,5 +13,9 @@ internal class SingleStreamFileSystem : IFileSystem
 
     Stream IFileSystem.Create(string path) => this.stream;
 
+    Stream IFileSystem.CreateAsynchronous(string path) => this.stream;
+
     Stream IFileSystem.OpenRead(string path) => this.stream;
+
+    Stream IFileSystem.OpenReadAsynchronous(string path) => this.stream;
 }