Added WriteAsync to MagickImage.

Author: dlemstra

src/Magick.NET.Core/IMagickImage.cs

@@ -3646,5 +3646,33 @@ public interface IMagickImage : IDisposable
         /// <param name="format">The format to use.</param>
         /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
         void Write(string fileName, MagickFormat format);
+
+#if NETSTANDARD
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task WriteAsync(Stream stream);
+
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <param name="defines">The defines to set.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task WriteAsync(Stream stream, IWriteDefines defines);
+
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <param name="format">The format to use.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task WriteAsync(Stream stream, MagickFormat format);
+#endif
     }
 }

src/Magick.NET/MagickImage.cs

@@ -6703,7 +6703,7 @@ public void Write(Stream stream)
                 if (stream.CanRead)
                     reader = new ReadWriteStreamDelegate(wrapper.Read);
 
-                _nativeInstance.WriteStream(Settings, writer, seeker, teller, reader);
+                _nativeInstance.WriteStream(_settings, writer, seeker, teller, reader);
             }
         }
 
@@ -6746,7 +6746,7 @@ public void Write(string fileName)
             Throw.IfNullOrEmpty(nameof(fileName), filePath);
 
             _nativeInstance.FileName = filePath;
-            _nativeInstance.WriteFile(Settings);
+            _nativeInstance.WriteFile(_settings);
         }
 
         /// <summary>
@@ -6773,6 +6773,51 @@ public void Write(string fileName, MagickFormat format)
             Write(fileName);
         }
 
+#if NETSTANDARD
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public Task WriteAsync(Stream stream)
+        {
+            Throw.IfNull(nameof(stream), stream);
+
+            var bytes = ToByteArray();
+            return stream.WriteAsync(bytes, 0, bytes.Length);
+        }
+
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <param name="defines">The defines to set.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public Task WriteAsync(Stream stream, IWriteDefines defines)
+        {
+            _settings.SetDefines(defines);
+            _settings.Format = defines.Format;
+            return WriteAsync(stream);
+        }
+
+        /// <summary>
+        /// Writes the image to the specified stream.
+        /// </summary>
+        /// <param name="stream">The stream to write the image data to.</param>
+        /// <param name="format">The format to use.</param>
+        /// <exception cref="MagickException">Thrown when an error is raised by ImageMagick.</exception>
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        public async Task WriteAsync(Stream stream, MagickFormat format)
+        {
+            var currentFormat = Format;
+            _settings.Format = format;
+            await WriteAsync(stream).ConfigureAwait(false);
+            Format = currentFormat;
+        }
+#endif
+
         internal static IMagickImage<QuantumType> Clone(IMagickImage<QuantumType> image)
             => image?.Clone();
 

tests/Magick.NET.Tests/MagickImageTests/TheWriteAsyncMethod.cs

@@ -0,0 +1,74 @@
+// Copyright 2013-2020 Dirk Lemstra <https://github.com/dlemstra/Magick.NET/>
+//
+// Licensed under the ImageMagick License (the "License"); you may not use this file except in
+// compliance with the License. You may obtain a copy of the License at
+//
+//   https://www.imagemagick.org/script/license.php
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the
+// License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+// either express or implied. See the License for the specific language governing permissions
+// and limitations under the License.
+
+#if NETCOREAPP
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using ImageMagick;
+using Xunit;
+
+namespace Magick.NET.Tests
+{
+    public partial class MagickImageTests
+    {
+        public class TheWriteAsyncMethod
+        {
+            public class WithStream
+            {
+                [Fact]
+                public async Task ShouldThrowExceptionWhenStreamIsNull()
+                {
+                    using (var image = new MagickImage())
+                    {
+                        await Assert.ThrowsAsync<ArgumentNullException>("stream", () => image.WriteAsync(null));
+                    }
+                }
+            }
+
+            public class WithStreamAndMagickFormat
+            {
+                [Fact]
+                public async Task ShouldThrowExceptionWhenStreamIsNull()
+                {
+                    using (var image = new MagickImage())
+                    {
+                        await Assert.ThrowsAsync<ArgumentNullException>("stream", () => image.WriteAsync(null, MagickFormat.Bmp));
+                    }
+                }
+
+                [Fact]
+                public async Task ShouldUseTheSpecifiedFormat()
+                {
+                    using (var input = new MagickImage(Files.CirclePNG))
+                    {
+                        using (var memoryStream = new MemoryStream())
+                        {
+                            using (var stream = new NonSeekableStream(memoryStream))
+                            {
+                                await input.WriteAsync(stream, MagickFormat.Tiff);
+                                Assert.Equal(MagickFormat.Png, input.Format);
+
+                                memoryStream.Position = 0;
+                                using (var output = new MagickImage(stream))
+                                {
+                                    Assert.Equal(MagickFormat.Tiff, output.Format);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+#endif