Add MemoryProvider Stream Write overloads

Author: mythz

src/ServiceStack.Memory/NetCoreMemory.cs

@@ -8,4 +8,9 @@
   <ItemGroup>
     <ProjectReference Include="..\ServiceStack.Text\ServiceStack.Text.csproj" />
   </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\ServiceStack.Text\NetCoreMemory.cs">
+      <Link>NetCoreMemory.cs</Link>
+    </Compile>
+  </ItemGroup>
 </Project>

src/ServiceStack.Memory/ServiceStack.Memory.csproj

@@ -422,8 +422,43 @@ public override Guid ParseGuid(ReadOnlySpan<char> value)
             return result;
         }
 
-        public override Task WriteAsync(Stream stream, ReadOnlySpan<char> value,
-            CancellationToken token = default(CancellationToken))
+        public override void Write(Stream stream, ReadOnlyMemory<char> value)
+        {
+            var bytes = BufferPool.GetBuffer(Encoding.UTF8.GetMaxByteCount(value.Length));
+            try
+            {
+                var chars = value.ToArray();
+                int bytesCount = Encoding.UTF8.GetBytes(chars, 0, chars.Length, bytes, 0);
+                stream.Write(bytes, 0, bytesCount);
+            }
+            finally
+            {
+                BufferPool.ReleaseBufferToPool(ref bytes);
+            }
+        }
+
+        public override void Write(Stream stream, ReadOnlyMemory<byte> value)
+        {
+            if (MemoryMarshal.TryGetArray(value, out var segment) && segment.Array != null)
+            {
+                byte[] bytes = BufferPool.GetBuffer(segment.Count);
+                try
+                {
+                    stream.Write(segment.Array, 0, segment.Count);
+                }
+                finally
+                {
+                    BufferPool.ReleaseBufferToPool(ref bytes);
+                }
+            }
+            else
+            {
+                var bytes = value.ToArray();
+                stream.Write(bytes, 0, value.Length);
+            }
+        }
+
+        public override Task WriteAsync(Stream stream, ReadOnlySpan<char> value, CancellationToken token = default)
         {
             byte[] bytes = BufferPool.GetBuffer(Encoding.UTF8.GetMaxByteCount(value.Length));
             try
@@ -438,6 +473,9 @@ public override Task WriteAsync(Stream stream, ReadOnlySpan<char> value,
             }
         }
 
+        public override Task WriteAsync(Stream stream, ReadOnlyMemory<char> value, CancellationToken token = default) =>
+            WriteAsync(stream, value.Span, token);
+
         public override Task WriteAsync(Stream stream, ReadOnlyMemory<byte> value, CancellationToken token = default)
         {
             byte[] bytes = BufferPool.GetBuffer(value.Length);

src/ServiceStack.Text/DefaultMemory.cs

@@ -50,9 +50,14 @@ public abstract class MemoryProvider
 
         public abstract string ToBase64(ReadOnlyMemory<byte> value);
 
-        public abstract Task WriteAsync(Stream stream, ReadOnlySpan<char> value, CancellationToken token = default);
+        public abstract void Write(Stream stream, ReadOnlyMemory<char> value);
+        public abstract void Write(Stream stream, ReadOnlyMemory<byte> value);
+
+        public abstract Task WriteAsync(Stream stream, ReadOnlyMemory<char> value, CancellationToken token = default);
         public abstract Task WriteAsync(Stream stream, ReadOnlyMemory<byte> value, CancellationToken token = default);
 
+        public abstract Task WriteAsync(Stream stream, ReadOnlySpan<char> value, CancellationToken token = default);
+
         public abstract object Deserialize(Stream stream, Type type, DeserializeStringSpanDelegate deserializer);
 
         public abstract Task<object> DeserializeAsync(Stream stream, Type type,

src/ServiceStack.Text/MemoryProvider.cs

@@ -95,26 +95,43 @@ public override string ToBase64(ReadOnlyMemory<byte> value)
             return Convert.ToBase64String(value.Span);
         }
 
-        public override Task WriteAsync(Stream stream, ReadOnlySpan<char> value, CancellationToken token=default)
+        public override void Write(Stream stream, ReadOnlyMemory<char> value)
         {
-            using (var writer = new BinaryWriter(stream, Encoding.UTF8, leaveOpen:true))
-            {
-                writer.Write(value);
-            }
+            var utf8 = ToUtf8(value.Span);
+            if (stream is MemoryStream ms)
+                ms.Write(utf8.Span);
+            else
+                stream.Write(utf8.Span);
+        }
+
+        public override void Write(Stream stream, ReadOnlyMemory<byte> value)
+        {
+            if (stream is MemoryStream ms)
+                ms.Write(value.Span);
+            else
+                stream.Write(value.Span);
+        }
+
+        public override Task WriteAsync(Stream stream, ReadOnlyMemory<char> value, CancellationToken token = default) =>
+            WriteAsync(stream, value.Span, token);
 
+        public override Task WriteAsync(Stream stream, ReadOnlySpan<char> value, CancellationToken token=default)
+        {
+            var utf8 = ToUtf8(value);
+            if (stream is MemoryStream ms)
+                ms.Write(utf8.Span);
+            else
+                return Task.FromResult(stream.WriteAsync(utf8, token));
+            
             return TypeConstants.EmptyTask;
         }
 
         public override async Task WriteAsync(Stream stream, ReadOnlyMemory<byte> value, CancellationToken token = default)
         {
             if (stream is MemoryStream ms)
-            {
                 ms.Write(value.Span);
-            }
             else
-            {
                 await stream.WriteAsync(value, token);
-            }
         }
 
         public override object Deserialize(Stream stream, Type type, DeserializeStringSpanDelegate deserializer)