Splits Publisher by introducing AsyncPublisher (#73)

src/main/MyNatsClient/IAsyncPublisher.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MyNatsClient
+{
+    public interface IAsyncPublisher
+    {
+        Task PubAsync(string subject, string body, string replyTo = null);
+        Task PubAsync(string subject, ReadOnlyMemory<byte> body, string replyTo = null);
+    }
+}

src/main/MyNatsClient/INatsClient.cs

@@ -143,7 +143,7 @@ public interface INatsClient
         /// is done.
         /// </summary>
         /// <param name="p"></param>
-        Task PubManyAsync(Func<IPublisher, Task> p);
+        Task PubManyAsync(Func<IAsyncPublisher, Task> p);
 
         /// <summary>
         /// Async request response.

src/main/MyNatsClient/IPublisher.cs

@@ -1,14 +1,10 @@
 using System;
-using System.Threading.Tasks;
 
 namespace MyNatsClient
 {
     public interface IPublisher
     {
         void Pub(string subject, string body, string replyTo = null);
         void Pub(string subject, ReadOnlyMemory<byte> body, string replyTo = null);
-
-        Task PubAsync(string subject, string body, string replyTo = null);
-        Task PubAsync(string subject, ReadOnlyMemory<byte> body, string replyTo = null);
     }
-}
+}

src/main/MyNatsClient/Internals/AsyncPublisher.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Threading.Tasks;
+using MyNatsClient.Internals.Commands;
+
+namespace MyNatsClient.Internals
+{
+    internal class AsyncPublisher : IAsyncPublisher
+    {
+        private readonly INatsStreamWriter _writer;
+        private readonly int _maxPayload;
+
+        internal AsyncPublisher(INatsStreamWriter writer, int maxPayload)
+        {
+            _writer = writer;
+            _maxPayload = maxPayload;
+        }
+
+        public Task PubAsync(string subject, string body, string replyTo = null)
+        {
+            var payload = NatsEncoder.GetBytes(body);
+            if (payload.Length > _maxPayload)
+                throw NatsException.ExceededMaxPayload(_maxPayload, payload.Length);
+
+            return PubCmd.WriteAsync(_writer, subject.AsMemory(), replyTo.AsMemory(), payload);
+        }
+
+        public Task PubAsync(string subject, ReadOnlyMemory<byte> body, string replyTo = null)
+        {
+            if (body.Length > _maxPayload)
+                throw NatsException.ExceededMaxPayload(_maxPayload, body.Length);
+
+            return PubCmd.WriteAsync(_writer, subject.AsMemory(), replyTo.AsMemory(), body);
+        }
+    }
+}

src/main/MyNatsClient/Internals/Publisher.cs

@@ -31,22 +31,5 @@ public void Pub(string subject, ReadOnlyMemory<byte> body, string replyTo = null
 
             PubCmd.Write(_writer, subject, replyTo, body);
         }
-
-        public Task PubAsync(string subject, string body, string replyTo = null)
-        {
-            var payload = NatsEncoder.GetBytes(body);
-            if (payload.Length > _maxPayload)
-                throw NatsException.ExceededMaxPayload(_maxPayload, payload.Length);
-
-            return PubCmd.WriteAsync(_writer, subject.AsMemory(), replyTo.AsMemory(), payload);
-        }
-
-        public Task PubAsync(string subject, ReadOnlyMemory<byte> body, string replyTo = null)
-        {
-            if (body.Length > _maxPayload)
-                throw NatsException.ExceededMaxPayload(_maxPayload, body.Length);
-
-            return PubCmd.WriteAsync(_writer, subject.AsMemory(), replyTo.AsMemory(), body);
-        }
     }
-}
+}

src/main/MyNatsClient/NatsClient.cs

@@ -467,15 +467,15 @@ public void PubMany(Action<IPublisher> p)
             });
         }
 
-        public async Task PubManyAsync(Func<IPublisher, Task> p)
+        public async Task PubManyAsync(Func<IAsyncPublisher, Task> p)
         {
             ThrowIfDisposed();
 
             ThrowIfNotConnected();
 
             await _connection.WithWriteLockAsync(async writer =>
             {
-                await p(new Publisher(writer, _connection.ServerInfo.MaxPayload)).ConfigureAwait(false);
+                await p(new AsyncPublisher(writer, _connection.ServerInfo.MaxPayload)).ConfigureAwait(false);
                 if (ShouldAutoFlush)
                     await writer.FlushAsync().ConfigureAwait(false);
             }).ConfigureAwait(false);