Add ByteString.FromStream and ByteString.FromStreamAsync in C#

Fixes #2088.

We now have separate tests for netcoreapp and net45 to test the two branches here.
(netstandard10 doesn't have MemoryStream.GetBuffer)

Although most of this library doesn't have any async functionality,
this feels like a natural place to locally add it.

3 files changed, 108 insertions, 1 deletions

diff --git a/csharp/src/Google.Protobuf.Test/ByteStringTest.cs b/csharp/src/Google.Protobuf.Test/ByteStringTest.cs
index ff2444a3..21aeb310 100644
--- a/csharp/src/Google.Protobuf.Test/ByteStringTest.cs
+++ b/csharp/src/Google.Protobuf.Test/ByteStringTest.cs
@@ -33,6 +33,10 @@
 using System;

 using System.Text;

 using NUnit.Framework;

+using System.IO;

+#if !DOTNET35

+using System.Threading.Tasks;

+#endif

 

 namespace Google.Protobuf

 {

@@ -169,6 +173,56 @@ namespace Google.Protobuf
         }

 

         [Test]

+        public void FromStream_Seekable()

+        {

+            var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });

+            // Consume the first byte, just to test that it's "from current position"

+            stream.ReadByte();

+            var actual = ByteString.FromStream(stream);

+            ByteString expected = ByteString.CopyFrom(2, 3, 4, 5);

+            Assert.AreEqual(expected, actual, $"{expected.ToBase64()} != {actual.ToBase64()}");

+        }

+

+        [Test]

+        public void FromStream_NotSeekable()

+        {

+            var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });

+            // Consume the first byte, just to test that it's "from current position"

+            stream.ReadByte();

+            // Wrap the original stream in LimitedInputStream, which has CanSeek=false

+            var limitedStream = new LimitedInputStream(stream, 3);

+            var actual = ByteString.FromStream(limitedStream);

+            ByteString expected = ByteString.CopyFrom(2, 3, 4);

+            Assert.AreEqual(expected, actual, $"{expected.ToBase64()} != {actual.ToBase64()}");

+        }

+

+#if !DOTNET35

+        [Test]

+        public async Task FromStreamAsync_Seekable()

+        {

+            var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });

+            // Consume the first byte, just to test that it's "from current position"

+            stream.ReadByte();

+            var actual = await ByteString.FromStreamAsync(stream);

+            ByteString expected = ByteString.CopyFrom(2, 3, 4, 5);

+            Assert.AreEqual(expected, actual, $"{expected.ToBase64()} != {actual.ToBase64()}");

+        }

+

+        [Test]

+        public async Task FromStreamAsync_NotSeekable()

+        {

+            var stream = new MemoryStream(new byte[] { 1, 2, 3, 4, 5 });

+            // Consume the first byte, just to test that it's "from current position"

+            stream.ReadByte();

+            // Wrap the original stream in LimitedInputStream, which has CanSeek=false

+            var limitedStream = new LimitedInputStream(stream, 3);

+            var actual = await ByteString.FromStreamAsync(limitedStream);

+            ByteString expected = ByteString.CopyFrom(2, 3, 4);

+            Assert.AreEqual(expected, actual, $"{expected.ToBase64()} != {actual.ToBase64()}");

+        }

+#endif

+

+        [Test]

         public void GetHashCode_Regression()

         {

             // We used to have an awful hash algorithm where only the last four

@@ -179,6 +233,5 @@ namespace Google.Protobuf
             ByteString b2 = ByteString.CopyFrom(200, 1, 2, 3, 4);

             Assert.AreNotEqual(b1.GetHashCode(), b2.GetHashCode());

         }

-

     }

 }
\ No newline at end of file
diff --git a/csharp/src/Google.Protobuf.Test/project.json b/csharp/src/Google.Protobuf.Test/project.json
index 3a73bf7a..9f739f90 100644
--- a/csharp/src/Google.Protobuf.Test/project.json
+++ b/csharp/src/Google.Protobuf.Test/project.json
@@ -27,6 +27,7 @@
   "testRunner": "nunit",
 
   "frameworks": {
+    "net451": {},
     "netcoreapp1.0": {
       "imports" : [ "dnxcore50", "netcoreapp1.0", "portable-net45+win8" ],
       "buildOptions": {
diff --git a/csharp/src/Google.Protobuf/ByteString.cs b/csharp/src/Google.Protobuf/ByteString.cs
index 5c652cc3..9973d211 100644
--- a/csharp/src/Google.Protobuf/ByteString.cs
+++ b/csharp/src/Google.Protobuf/ByteString.cs
@@ -35,6 +35,10 @@ using System.Collections;
 using System.Collections.Generic;

 using System.IO;

 using System.Text;

+#if !DOTNET35

+using System.Threading;

+using System.Threading.Tasks;

+#endif

 

 namespace Google.Protobuf

 {

@@ -142,6 +146,55 @@ namespace Google.Protobuf
         }

 

         /// <summary>

+        /// Constructs a <see cref="ByteString"/> from data in the given stream, synchronously.

+        /// </summary>

+        /// <remarks>If successful, <paramref name="stream"/> will be read completely, from the position

+        /// at the start of the call.</remarks>

+        /// <param name="stream">The stream to copy into a ByteString.</param>

+        /// <returns>A ByteString with content read from the given stream.</returns>

+        public static ByteString FromStream(Stream stream)

+        {

+            ProtoPreconditions.CheckNotNull(stream, nameof(stream));

+            int capacity = stream.CanSeek ? checked((int) (stream.Length - stream.Position)) : 0;

+            var memoryStream = new MemoryStream(capacity);

+            stream.CopyTo(memoryStream);

+#if NETSTANDARD1_0

+            byte[] bytes = memoryStream.ToArray();

+#else

+            // Avoid an extra copy if we can.

+            byte[] bytes = memoryStream.Length == memoryStream.Capacity ? memoryStream.GetBuffer() : memoryStream.ToArray();

+#endif

+            return AttachBytes(bytes);

+        }

+

+#if !DOTNET35

+        /// <summary>

+        /// Constructs a <see cref="ByteString"/> from data in the given stream, asynchronously.

+        /// </summary>

+        /// <remarks>If successful, <paramref name="stream"/> will be read completely, from the position

+        /// at the start of the call.</remarks>

+        /// <param name="stream">The stream to copy into a ByteString.</param>

+        /// <param name="cancellationToken">The cancellation token to use when reading from the stream, if any.</param>

+        /// <returns>A ByteString with content read from the given stream.</returns>

+        public async static Task<ByteString> FromStreamAsync(Stream stream, CancellationToken cancellationToken = default(CancellationToken))

+        {

+            ProtoPreconditions.CheckNotNull(stream, nameof(stream));

+            int capacity = stream.CanSeek ? checked((int) (stream.Length - stream.Position)) : 0;

+            var memoryStream = new MemoryStream(capacity);

+            // We have to specify the buffer size here, as there's no overload accepting the cancellation token

+            // alone. But it's documented to use 81920 by default if not specified.

+            await stream.CopyToAsync(memoryStream, 81920, cancellationToken);

+#if NETSTANDARD1_0

+            byte[] bytes = memoryStream.ToArray();

+#else

+            // Avoid an extra copy if we can.

+            byte[] bytes = memoryStream.Length == memoryStream.Capacity ? memoryStream.GetBuffer() : memoryStream.ToArray();

+#endif

+            return AttachBytes(bytes);

+        }

+#endif

+

+        /// <summary>

         /// Constructs a <see cref="ByteString" /> from the given array. The contents

         /// are copied, so further modifications to the array will not

         /// be reflected in the returned ByteString.