Added WriteAsync to MagickImageCollection.

Author: dlemstra

src/Magick.NET.Core/IMagickImageCollection.cs

@@ -394,5 +394,35 @@ public interface IMagickImageCollection : 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 imagse to the specified stream. If the output image's file format does not
+        /// allow multi-image files multiple files will be written.
+        /// </summary>
+        /// <param name="stream">The stream to write the images 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 imagse to the specified stream. If the output image's file format does not
+        /// allow multi-image files multiple files will be written.
+        /// </summary>
+        /// <param name="stream">The stream to write the images 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/MagickImageCollection.cs

@@ -1551,6 +1551,66 @@ public void Write(string fileName, MagickFormat format)
             Write(fileName);
         }
 
+#if NETSTANDARD
+        /// <summary>
+        /// Writes the imagse to the specified stream. If the output image's file format does not
+        /// allow multi-image files multiple files will be written.
+        /// </summary>
+        /// <param name="stream">The stream to write the images 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 async Task WriteAsync(Stream stream)
+        {
+            Throw.IfNull(nameof(stream), stream);
+
+            if (_images.Count == 0)
+                return;
+
+            var settings = _images[0].GetSettings().Clone();
+            settings.FileName = null;
+
+            try
+            {
+                AttachImages();
+
+                var bytes = ToByteArray();
+                await stream.WriteAsync(bytes, 0, bytes.Length).ConfigureAwait(false);
+            }
+            finally
+            {
+                DetachImages();
+            }
+        }
+
+        /// <summary>
+        /// Writes the imagse to the specified stream. If the output image's file format does not
+        /// allow multi-image files multiple files will be written.
+        /// </summary>
+        /// <param name="stream">The stream to write the images 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)
+        {
+            SetDefines(defines);
+            SetFormat(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 Task WriteAsync(Stream stream, MagickFormat format)
+        {
+            SetFormat(format);
+            return WriteAsync(stream);
+        }
+#endif
+
         private static MagickSettings CreateSettings(IMagickReadSettings<QuantumType> readSettings)
         {
             if (readSettings == null)

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

@@ -0,0 +1,86 @@
+// 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 MagickImageCollectionTests
+    {
+        public class TheWriteAsyncMethod
+        {
+            public class WithStream
+            {
+                [Fact]
+                public async Task ShouldThrowExceptionWhenFileIsNull()
+                {
+                    using (var images = new MagickImageCollection())
+                    {
+                        await Assert.ThrowsAsync<ArgumentNullException>("stream", () => images.WriteAsync(null));
+                    }
+                }
+            }
+
+            public class WithStreamAndFormat
+            {
+                [Fact]
+                public async Task ShouldThrowExceptionWhenStreamIsNull()
+                {
+                    using (var images = new MagickImageCollection())
+                    {
+                        await Assert.ThrowsAsync<ArgumentNullException>("stream", () => images.WriteAsync(null, MagickFormat.Bmp));
+                    }
+                }
+
+                [Fact]
+                public async Task ShouldUseTheSpecifiedFormat()
+                {
+                    using (var input = new MagickImageCollection(Files.CirclePNG))
+                    {
+                        using (var memoryStream = new MemoryStream())
+                        {
+                            using (var stream = new NonSeekableStream(memoryStream))
+                            {
+                                await input.WriteAsync(stream, MagickFormat.Tiff);
+
+                                memoryStream.Position = 0;
+                                using (var output = new MagickImageCollection(stream))
+                                {
+                                    Assert.Single(output);
+                                    Assert.Equal(MagickFormat.Tiff, output[0].Format);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                [Fact]
+                public async Task ShouldThrowExceptionWhenFormatIsNotWritable()
+                {
+                    using (var input = new MagickImageCollection(Files.CirclePNG))
+                    {
+                        using (var memoryStream = new MemoryStream())
+                        {
+                            await Assert.ThrowsAsync<MagickMissingDelegateErrorException>(() => input.WriteAsync(memoryStream, MagickFormat.Xc));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+#endif