refactoring

Author: jacqueskang

…erviceFramework/IIpcServiceCollection.cs …amework/Hosting/IIpcServiceCollection.cssrc/JKang.IpcServiceFramework/IIpcServiceCollection.cs renamed to src/JKang.IpcServiceFramework/Hosting/IIpcServiceCollection.cs src/JKang.IpcServiceFramework/IIpcServiceCollection.cs renamed to src/JKang.IpcServiceFramework/Hosting/IIpcServiceCollection.cs

@@ -1,14 +1,11 @@
-using Microsoft.Extensions.DependencyInjection;
+using JKang.IpcServiceFramework.IO;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using System;
 using System.IO;
 using System.IO.Pipes;
 using System.Reflection;
-using System.Runtime.CompilerServices;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace JKang.IpcServiceFramework
 {
@@ -17,52 +14,49 @@ public class IpcServiceHost : IIpcServiceHost
         private readonly string _pipeName;
         private readonly IServiceProvider _serviceProvider;
         private readonly ILogger<IpcServiceHost> _logger;
+        private readonly IIpcMessageSerializer _serializer;
 
         public IpcServiceHost(string pipeName, IServiceProvider serviceProvider)
         {
             _pipeName = pipeName;
             _serviceProvider = serviceProvider;
             _logger = _serviceProvider.GetService<ILogger<IpcServiceHost>>();
+            _serializer = _serviceProvider.GetRequiredService<IIpcMessageSerializer>();
         }
 
         public void Start()
         {
             using (var server = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, 1))
-            using (var reader = new BinaryReader(server))
-            using (var writer = new BinaryWriter(server))
+            using (var writer = new IpcWriter(server, _serializer))
+            using (var reader = new IpcReader(server, _serializer))
             {
+                _logger?.LogInformation("IPC server started.");
                 while (true)
                 {
-                    _logger.LogInformation("IPC service started. Waiting for connection");
+                    _logger?.LogDebug("Waiting for connection...");
                     server.WaitForConnection();
 
-                    _logger.LogDebug("client connected");
                     try
                     {
+                        _logger?.LogDebug("client connected, reading request...");
+                        IpcRequest request = reader.ReadIpcRequest();
+
+                        _logger?.LogDebug("request received, invoking corresponding method...");
+                        IpcResponse response;
                         using (IServiceScope scope = _serviceProvider.CreateScope())
                         {
-                            IIpcMessageSerializer serializer = scope.ServiceProvider.GetRequiredService<IIpcMessageSerializer>();
-
-                            int requestLength = reader.ReadInt32();
-                            byte[] requestBin = reader.ReadBytes(requestLength);
-                            IpcRequest request = serializer.DeserializeRequest(requestBin);
-
-                            _logger.LogDebug("request received, invoking corresponding method...");
-                            IpcResponse response = GetReponse(request, scope);
+                            response = GetReponse(request, scope);
+                        }
 
-                            _logger.LogDebug("sending response...");
-                            byte[] responseBin = serializer.SerializeResponse(response);
-                            writer.Write(responseBin.Length);
-                            writer.Write(responseBin);
-                            writer.Flush();
+                        _logger?.LogDebug("sending response...");
+                        writer.Write(response);
 
-                            // disconnect client
-                            server.Disconnect();
-                        }
+                        // disconnect client
+                        server.Disconnect();
                     }
                     catch (Exception ex)
                     {
-                        _logger.LogError(ex, ex.Message);
+                        _logger?.LogError(ex, ex.Message);
                         server.Disconnect();
                     }
                 }

…g.IpcServiceFramework/IIpcServiceHost.cs …viceFramework/Hosting/IIpcServiceHost.cssrc/JKang.IpcServiceFramework/IIpcServiceHost.cs renamed to src/JKang.IpcServiceFramework/Hosting/IIpcServiceHost.cs src/JKang.IpcServiceFramework/IIpcServiceHost.cs renamed to src/JKang.IpcServiceFramework/Hosting/IIpcServiceHost.cs

@@ -0,0 +1,62 @@
+using System;
+using System.IO;
+
+namespace JKang.IpcServiceFramework.IO
+{
+    public class IpcReader : IDisposable
+    {
+        private readonly BinaryReader _reader;
+        private readonly IIpcMessageSerializer _serializer;
+
+        public IpcReader(Stream stream, IIpcMessageSerializer serializer)
+        {
+            _reader = new BinaryReader(stream);
+            _serializer = serializer;
+        }
+
+        public IpcRequest ReadIpcRequest()
+        {
+            byte[] binary = ReadMessage();
+            return _serializer.DeserializeRequest(binary);
+        }
+
+        public IpcResponse ReadIpcResponse()
+        {
+            byte[] binary = ReadMessage();
+            return _serializer.DeserializeResponse(binary);
+        }
+
+        private byte[] ReadMessage()
+        {
+            int length = _reader.ReadInt32();
+            return _reader.ReadBytes(length);
+        }
+
+        #region IDisposible
+
+        bool _disposed = false;
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _reader.Dispose();
+            }
+
+            _disposed = true;
+        }
+
+        #endregion
+    }
+}

…ServiceFramework/IpcServiceCollection.cs …ramework/Hosting/IpcServiceCollection.cssrc/JKang.IpcServiceFramework/IpcServiceCollection.cs renamed to src/JKang.IpcServiceFramework/Hosting/IpcServiceCollection.cs src/JKang.IpcServiceFramework/IpcServiceCollection.cs renamed to src/JKang.IpcServiceFramework/Hosting/IpcServiceCollection.cs

@@ -0,0 +1,62 @@
+using System;
+using System.IO;
+
+namespace JKang.IpcServiceFramework.IO
+{
+    public class IpcWriter: IDisposable
+    {
+        private readonly BinaryWriter _writer;
+        private readonly IIpcMessageSerializer _serializer;
+
+        public IpcWriter(Stream stream, IIpcMessageSerializer serializer)
+        {
+            _writer = new BinaryWriter(stream);
+            _serializer = serializer;
+        }
+
+        public void Write(IpcRequest request)
+        {
+            byte[] binary = _serializer.SerializeRequest(request);
+            WriteMessage(binary);
+        }
+
+        public void Write(IpcResponse response)
+        {
+            byte[] binary = _serializer.SerializeResponse(response);
+            WriteMessage(binary);
+        }
+
+        private void WriteMessage(byte[] binary)
+        {
+            _writer.Write(binary.Length);
+            _writer.Write(binary);
+        }
+
+        #region IDisposible
+
+        bool _disposed = false;
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            if (disposing)
+            {
+                _writer.Dispose();
+            }
+
+            _disposed = true;
+        }
+
+        #endregion
+    }
+}

…ng.IpcServiceFramework/IpcServiceHost.cs …rviceFramework/Hosting/IpcServiceHost.cssrc/JKang.IpcServiceFramework/IpcServiceHost.cs renamed to src/JKang.IpcServiceFramework/Hosting/IpcServiceHost.cs src/JKang.IpcServiceFramework/IpcServiceHost.cs renamed to src/JKang.IpcServiceFramework/Hosting/IpcServiceHost.cs

@@ -1,4 +1,5 @@
-using Newtonsoft.Json.Linq;
+using JKang.IpcServiceFramework.IO;
+using Newtonsoft.Json.Linq;
 using System;
 using System.IO;
 using System.IO.Pipes;
@@ -24,27 +25,21 @@ public IpcServiceClient(string pipeName, IIpcMessageSerializer requestSerializer
         public async Task<TResult> InvokeAsync<TResult>(string method, params object[] args)
         {
             using (var client = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.None))
+            using (var writer = new IpcWriter(client, _serializer))
+            using (var reader = new IpcReader(client, _serializer))
             {
                 await client.ConnectAsync();
 
                 // send request
-                var request = new IpcRequest
+                writer.Write(new IpcRequest
                 {
                     InterfaceName = typeof(TInterface).AssemblyQualifiedName,
                     MethodName = method,
                     Parameters = args,
-                };
-                byte[] requestBin = _serializer.SerializeRequest(request);
-                var writer = new BinaryWriter(client);
-                writer.Write(requestBin.Length);
-                writer.Write(requestBin);
-                await client.FlushAsync();
+                });
 
                 // receive response
-                var reader = new BinaryReader(client);
-                int responseLength = reader.ReadInt32();
-                byte[] responseBin = reader.ReadBytes(responseLength);
-                IpcResponse response = _serializer.DeserializeResponse(responseBin);
+                IpcResponse response = reader.ReadIpcResponse();
                 if (response.Succeed)
                 {
                     // TODO: handle primitive types