refactoring

Author: jacqueskang

src/IpcServiceSample.ConsoleServer/Program.cs

@@ -27,10 +27,15 @@ static void Main(string[] args)
 
         private static IServiceCollection ConfigureServices(IServiceCollection services)
         {
-            return services
-                .AddLogging()
-                .AddScoped<IMyIpcService, MyIpcService>()
+            services
+                .AddLogging();
+
+            services
+                .AddIpc()
+                .AddService<IMyIpcService, MyIpcService>()
                 ;
+
+            return services;
         }
     }
 }

src/JKang.IpcServiceFramework/DefaultIpcMessageSerializer.cs

@@ -0,0 +1,45 @@
+using Newtonsoft.Json;
+using System.Text;
+
+namespace JKang.IpcServiceFramework
+{
+    internal class DefaultIpcMessageSerializer : IIpcMessageSerializer
+    {
+        private static readonly JsonSerializerSettings _settings = new JsonSerializerSettings
+        {
+            TypeNameHandling = TypeNameHandling.Objects
+        };
+
+        public IpcRequest DeserializeRequest(byte[] binary)
+        {
+            return Deserialize<IpcRequest>(binary);
+        }
+
+        public IpcResponse DeserializeResponse(byte[] binary)
+        {
+            return Deserialize<IpcResponse>(binary);
+        }
+
+        public byte[] SerializeRequest(IpcRequest request)
+        {
+            return Serialize(request);
+        }
+
+        public byte[] SerializeResponse(IpcResponse response)
+        {
+            return Serialize(response);
+        }
+
+        private T Deserialize<T>(byte[] binary)
+        {
+            string json = Encoding.UTF8.GetString(binary);
+            return JsonConvert.DeserializeObject<T>(json);
+        }
+
+        private byte[] Serialize(object obj)
+        {
+            string json = JsonConvert.SerializeObject(obj, _settings);
+            return Encoding.UTF8.GetBytes(json);
+        }
+    }
+}

src/JKang.IpcServiceFramework/IIpcMessageSerializer.cs

@@ -0,0 +1,10 @@
+namespace JKang.IpcServiceFramework
+{
+    public interface IIpcMessageSerializer
+    {
+        byte[] SerializeRequest(IpcRequest request);
+        IpcResponse DeserializeResponse(byte[] binary);
+        IpcRequest DeserializeRequest(byte[] binary);
+        byte[] SerializeResponse(IpcResponse response);
+    }
+}

src/JKang.IpcServiceFramework/IIpcServiceCollection.cs

@@ -0,0 +1,9 @@
+namespace JKang.IpcServiceFramework
+{
+    public interface IIpcServiceCollection
+    {
+        IIpcServiceCollection AddService<TInterface, TImplementation>()
+            where TInterface: class
+            where TImplementation: class, TInterface;
+    }
+}

src/JKang.IpcServiceFramework/IpcRequest.cs

@@ -1,6 +1,6 @@
 namespace JKang.IpcServiceFramework
 {
-    internal class IpcRequest
+    public class IpcRequest
     {
         public string InterfaceName { get; set; }
         public string MethodName { get; set; }

src/JKang.IpcServiceFramework/IpcServiceClient.cs

@@ -1,20 +1,24 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using Newtonsoft.Json.Linq;
 using System;
 using System.IO;
 using System.IO.Pipes;
-using System.Text;
 using System.Threading.Tasks;
 
 namespace JKang.IpcServiceFramework
 {
     public abstract class IpcServiceClient<TInterface>
     {
         private readonly string _pipeName;
+        private readonly IIpcMessageSerializer _serializer;
 
         public IpcServiceClient(string pipeName)
+            : this(pipeName, new DefaultIpcMessageSerializer())
+        { }
+
+        public IpcServiceClient(string pipeName, IIpcMessageSerializer requestSerializer)
         {
             _pipeName = pipeName;
+            _serializer = requestSerializer;
         }
 
         public async Task<TResult> InvokeAsync<TResult>(string method, params object[] args)
@@ -30,17 +34,17 @@ public async Task<TResult> InvokeAsync<TResult>(string method, params object[] a
                     MethodName = method,
                     Parameters = args,
                 };
-                string json = JsonConvert.SerializeObject(request);
-                byte[] bytes = Encoding.UTF8.GetBytes(json);
+                byte[] requestBin = _serializer.SerializeRequest(request);
                 var writer = new BinaryWriter(client);
-                writer.Write(bytes.Length);
-                writer.Write(bytes);
+                writer.Write(requestBin.Length);
+                writer.Write(requestBin);
                 await client.FlushAsync();
 
                 // receive response
-                var reader = new StreamReader(client);
-                string responseJson = await reader.ReadToEndAsync();
-                IpcResponse response = JsonConvert.DeserializeObject<IpcResponse>(responseJson);
+                var reader = new BinaryReader(client);
+                int responseLength = reader.ReadInt32();
+                byte[] responseBin = reader.ReadBytes(responseLength);
+                IpcResponse response = _serializer.DeserializeResponse(responseBin);
                 if (response.Succeed)
                 {
                     // TODO: handle primitive types

src/JKang.IpcServiceFramework/IpcServiceCollection.cs

@@ -0,0 +1,20 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JKang.IpcServiceFramework
+{
+    internal class IpcServiceCollection : IIpcServiceCollection
+    {
+        private readonly IServiceCollection _services;
+
+        public IpcServiceCollection(IServiceCollection services)
+        {
+            _services = services;
+        }
+
+        IIpcServiceCollection IIpcServiceCollection.AddService<TInterface, TImplementation>()
+        {
+            _services.AddScoped<TInterface, TImplementation>();
+            return this;
+        }
+    }
+}

src/JKang.IpcServiceFramework/IpcServiceHost.cs

@@ -29,34 +29,36 @@ public void Start()
         {
             using (var server = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, 1))
             using (var reader = new BinaryReader(server))
-            using (var writer = new StreamWriter(server))
+            using (var writer = new BinaryWriter(server))
             {
                 while (true)
                 {
                     _logger.LogInformation("IPC service started. Waiting for connection");
                     server.WaitForConnection();
 
+                    _logger.LogDebug("client connected");
                     try
                     {
-                        _logger.LogDebug("client connected");
-
-                        int length = reader.ReadInt32();
-                        byte[] bytes = reader.ReadBytes(length);
-                        string json = Encoding.UTF8.GetString(bytes);
-                        IpcRequest request = JsonConvert.DeserializeObject<IpcRequest>(json);
-
-                        _logger.LogDebug("request received, invoking corresponding method...");
-                        IpcResponse response;
                         using (IServiceScope scope = _serviceProvider.CreateScope())
                         {
-                            response = GetReponse(request, scope);
-                        }
+                            IIpcMessageSerializer serializer = scope.ServiceProvider.GetRequiredService<IIpcMessageSerializer>();
 
-                        _logger.LogDebug("sending response...");
-                        string resultJson = JsonConvert.SerializeObject(response);
-                        writer.Write(resultJson);
-                        writer.Flush();
-                        server.Disconnect();
+                            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);
+
+                            _logger.LogDebug("sending response...");
+                            byte[] responseBin = serializer.SerializeResponse(response);
+                            writer.Write(responseBin.Length);
+                            writer.Write(responseBin);
+                            writer.Flush();
+
+                            // disconnect client
+                            server.Disconnect();
+                        }
                     }
                     catch (Exception ex)
                     {

src/JKang.IpcServiceFramework/IpcServiceServiceCollectionExtensions.cs

@@ -0,0 +1,15 @@
+using Microsoft.Extensions.DependencyInjection;
+
+namespace JKang.IpcServiceFramework
+{
+    public static class IpcServiceServiceCollectionExtensions
+    {
+        public static IIpcServiceCollection AddIpc(this IServiceCollection services)
+        {
+            services
+                .AddScoped<IIpcMessageSerializer, DefaultIpcMessageSerializer>();
+
+            return new IpcServiceCollection(services);
+        }
+    }
+}