Merge pull request #2 from Shuttle/async

Async

Author: eben-roux

README.md

@@ -8,12 +8,14 @@ Provides `Stream` extensions.
 
 ``` c#
 byte[] ToBytes(this Stream stream)
+Task<byte[]> ToBytesAsync(this Stream stream)
 ```
 
 Returns the given `stream` as a `byte` array.
 
 ``` c#
 Stream Copy(this Stream stream)
+Task<Stream> CopyAsync(this Stream stream)
 ```
 
 Creates a copyof the given `stream`.  THe copy will be at position 0 and the source `stream` will remain at its original position.

Shuttle.Core.Streams.Tests/Shuttle.Core.Streams.Tests.csproj

@@ -1,13 +1,13 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>net6.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.0" />
-    <PackageReference Include="NUnit" Version="3.13.3" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.3.1" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="NUnit" Version="3.14.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 
   <ItemGroup>

Shuttle.Core.Streams.Tests/StreamExtensionsFixture.cs

@@ -1,4 +1,5 @@
 using System.IO;
+using System.Threading.Tasks;
 using NUnit.Framework;
 
 namespace Shuttle.Core.Streams.Tests
@@ -17,6 +18,17 @@ public void Should_be_able_to_convert_a_stream_to_an_array_of_bytes()
             Assert.AreEqual(4, bytes[4]);
         }
 
+        [Test]
+        public async Task Should_be_able_to_convert_a_stream_to_an_array_of_bytes_async()
+        {
+            var stream = new MemoryStream(new byte[] {0, 1, 2, 3, 4});
+            var bytes = await stream.ToBytesAsync();
+
+            Assert.AreEqual(5, bytes.Length);
+            Assert.AreEqual(0, bytes[0]);
+            Assert.AreEqual(4, bytes[4]);
+        }
+
         [Test]
         public void Should_be_able_to_make_a_copy_of_a_stream()
         {
@@ -56,5 +68,45 @@ public void Should_be_able_to_make_a_readonly_copy_of_a_stream()
             Assert.AreEqual(0, copy.Position);
             Assert.AreEqual(5, stream.Position);
         }
+
+        [Test]
+        public async Task Should_be_able_to_make_a_copy_of_a_stream_async()
+        {
+            var bytes = new byte[] {0, 1, 2, 3, 4};
+            var stream = new MemoryStream(bytes);
+            var output = new MemoryStream();
+
+            await stream.CopyToAsync(output);
+
+            Assert.AreEqual(5, output.Length);
+            Assert.AreEqual(5, output.Position);
+            Assert.AreEqual(5, stream.Position);
+
+            var copy = await stream.CopyAsync();
+
+            Assert.AreEqual(5, copy.Length);
+            Assert.AreEqual(0, copy.Position);
+            Assert.AreEqual(5, stream.Position);
+        }
+
+        [Test]
+        public async Task Should_be_able_to_make_a_readonly_copy_of_a_stream_async()
+        {
+            var bytes = new byte[] {0, 1, 2, 3, 4};
+            var stream = new MemoryStream(bytes, 0, bytes.Length, false, true);
+            var output = new MemoryStream();
+
+            await stream.CopyToAsync(output);
+
+            Assert.AreEqual(5, output.Length);
+            Assert.AreEqual(5, output.Position);
+            Assert.AreEqual(5, stream.Position);
+
+            var copy = await stream.CopyAsync();
+
+            Assert.AreEqual(5, copy.Length);
+            Assert.AreEqual(0, copy.Position);
+            Assert.AreEqual(5, stream.Position);
+        }
     }
 }

Shuttle.Core.Streams/.package/package.nuspec

@@ -3,7 +3,7 @@
 <package>
 	<metadata>
 		<id>Shuttle.Core.Streams</id>
-		<version>10.1.1</version>
+		<version>10.2.0</version>
 		<authors>Eben Roux</authors>
 		<owners>Eben Roux</owners>
 		<license type="expression">BSD-3-Clause</license>
@@ -13,10 +13,10 @@
 		<repository type="git" url="https://github.com/shuttle/Shuttle.Core.Streams.git" />
 		<projectUrl>https://github.com/shuttle/Shuttle.Core.Streams</projectUrl>
 		<description>Stream infrastructure utilities.</description>
-		<copyright>Copyright (c) 2022, Eben Roux</copyright>
+		<copyright>Copyright (c) 2024, Eben Roux</copyright>
 		<tags>shuttle stream</tags>
 		<dependencies>
-      <dependency id="Shuttle.Core.Contract" version="11.0.0" />
+      <dependency id="Shuttle.Core.Contract" version="11.1.0" />
 		</dependencies>
 	</metadata>
 	<files>

Shuttle.Core.Streams/Properties/AssemblyInfo.cs

@@ -13,10 +13,10 @@
 [assembly: AssemblyTitle(".NET Standard")]
 #endif
 
-[assembly: AssemblyVersion("10.1.1.0")]
-[assembly: AssemblyCopyright("Copyright (c) 2022, Eben Roux")]
+[assembly: AssemblyVersion("10.2.0.0")]
+[assembly: AssemblyCopyright("Copyright (c) 2024, Eben Roux")]
 [assembly: AssemblyProduct("Shuttle.Core.Streams")]
 [assembly: AssemblyCompany("Eben Roux")]
 [assembly: AssemblyConfiguration("Release")]
-[assembly: AssemblyInformationalVersion("10.1.1")]
+[assembly: AssemblyInformationalVersion("10.2.0")]
 [assembly: ComVisible(false)]

Shuttle.Core.Streams/Shuttle.Core.Streams.csproj

@@ -14,7 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Shuttle.Core.Contract" Version="11.0.0" />
+    <PackageReference Include="Shuttle.Core.Contract" Version="11.1.0" />
   </ItemGroup>
 
   <ItemGroup>

Shuttle.Core.Streams/StreamExtensions.cs

@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Threading.Tasks;
 using Shuttle.Core.Contract;
 
 namespace Shuttle.Core.Streams
@@ -13,18 +14,46 @@ public static class StreamExtensions
         /// <returns>An array of bytes</returns>
         public static byte[] ToBytes(this Stream stream)
         {
-            using (var result = (MemoryStream)stream.Copy())
+            using (var result = (MemoryStream)Guard.AgainstNull(stream, nameof(stream)).Copy())
             {
                 return result.ToArray();
             }
         }
 
+        /// <summary>
+        ///     Creates an array of bytes from the given stream.  The stream position is reset once the operation has completed.
+        /// </summary>
+        /// <param name="stream">Input stream</param>
+        /// <returns>An array of bytes</returns>
+        public static async Task<byte[]> ToBytesAsync(this Stream stream)
+        {
+            using (var result = (MemoryStream)(await Guard.AgainstNull(stream, nameof(stream)).CopyAsync()))
+            {
+                return await Task.FromResult(result.ToArray());
+            }
+        }
+
         /// <summary>
         /// Returns a copy of the given stream.  The underlying type used is a `MemoryStream` and if the given `stream` is a `MemoryStream` the operation will attempt to use internal buffer if exposed and return a read-only stream; else a standard `MemoryStream` is used and the `stream` data copied to the that.
         /// </summary>
         /// <param name="stream">The `Stream` instance that contains the source data.</param>
         /// <returns>A new `MemoryStream` object.</returns>
         public static Stream Copy(this Stream stream)
+        {
+            return CopyAsync(stream, true).GetAwaiter().GetResult();
+        }
+
+        /// <summary>
+        /// Returns a copy of the given stream.  The underlying type used is a `MemoryStream` and if the given `stream` is a `MemoryStream` the operation will attempt to use internal buffer if exposed and return a read-only stream; else a standard `MemoryStream` is used and the `stream` data copied to the that.
+        /// </summary>
+        /// <param name="stream">The `Stream` instance that contains the source data.</param>
+        /// <returns>A new `MemoryStream` object.</returns>
+        public static async Task<Stream> CopyAsync(this Stream stream)
+        {
+            return await CopyAsync(stream, false).ConfigureAwait(false);
+        }
+
+        private static async Task<Stream> CopyAsync(this Stream stream, bool sync)
         {
             Guard.AgainstNull(stream, nameof(stream));
 
@@ -44,7 +73,14 @@ public static Stream Copy(this Stream stream)
                 {
                     stream.Seek(0, SeekOrigin.Begin);
 
-                    stream.CopyTo(result);
+                    if (sync)
+                    {
+                        stream.CopyTo(result);
+                    }
+                    else
+                    {
+                        await stream.CopyToAsync(result).ConfigureAwait(false);
+                    }
 
                     result.Seek(0, SeekOrigin.Begin);
                 }