initial implementation

Author: Jacques Kang

src/IpcServiceSample.ConsoleClient/MyClient.cs

@@ -13,7 +13,7 @@ public MyClient(string pipeName)
 
         public Task<MyResponse> GetDataAsync(MyRequest request, bool iAmHandsome)
         {
-            throw new NotImplementedException();
+            return InvokeAsync<MyResponse>(nameof(GetDataAsync), request, iAmHandsome);
         }
     }
 }

src/IpcServiceSample.ConsoleClient/Program.cs

@@ -12,14 +12,12 @@ static void Main(string[] args)
 
         private static async Task MainAsync()
         {
-            var client = new MyClient("testpipe");
-            var request = new MyRequest
+            Console.WriteLine("Invoking IpcService...");
+            var client = new MyClient("pipeName");
+            MyResponse response = await client.GetDataAsync(new MyRequest
             {
                 Message = "Hello"
-            };
-
-            Console.WriteLine("Invoking IpcService...");
-            MyResponse response = await client.GetDataAsync(request, true);
+            }, iAmHandsome: true);
 
             Console.WriteLine($"Received response: {response.Message}");
         }

src/IpcServiceSample.ConsoleServer/Program.cs

@@ -25,8 +25,8 @@ static void Main(string[] args)
                 .AddConsole(LogLevel.Debug);
 
             // TODO start IPC service host
-            IpcServiceHost
-                .Buid(serviceProvider as IServiceProvider)
+            IpcServiceHostBuilder
+                .Buid("pipeName", serviceProvider as IServiceProvider)
                 .Start();
 
         }

src/JKang.IpcServiceFramework/IpcRequest.cs

@@ -0,0 +1,9 @@
+namespace JKang.IpcServiceFramework
+{
+    internal class IpcRequest
+    {
+        public string InterfaceName { get; set; }
+        public string MethodName { get; set; }
+        public object[] Parameters { get; set; }
+    }
+}

src/JKang.IpcServiceFramework/IpcResponse.cs

@@ -0,0 +1,30 @@
+using System;
+using Newtonsoft.Json;
+
+namespace JKang.IpcServiceFramework
+{
+    public class IpcResponse
+    {
+        [JsonConstructor]
+        private IpcResponse(bool succeed, object data, string failure)
+        {
+            Succeed = succeed;
+            Data = data;
+            Failure = failure;
+        }
+
+        public static IpcResponse Fail(string failure)
+        {
+            return new IpcResponse(false, null, failure);
+        }
+
+        public static IpcResponse Success(object data)
+        {
+            return new IpcResponse(true, data, null);
+        }
+
+        public bool Succeed { get; }
+        public object Data { get; }
+        public string Failure { get; }
+    }
+}

src/JKang.IpcServiceFramework/IpcServiceClient.cs

@@ -1,12 +1,55 @@
-namespace JKang.IpcServiceFramework
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using System;
+using System.IO;
+using System.IO.Pipes;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace JKang.IpcServiceFramework
 {
-    public class IpcServiceClient<TInterface>
+    public abstract class IpcServiceClient<TInterface>
     {
         private readonly string _pipeName;
 
         public IpcServiceClient(string pipeName)
         {
             _pipeName = pipeName;
         }
+
+        public async Task<TResult> InvokeAsync<TResult>(string method, params object[] args)
+        {
+            using (var client = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.None))
+            {
+                await client.ConnectAsync();
+
+                // send request
+                var request = new IpcRequest
+                {
+                    InterfaceName = typeof(TInterface).AssemblyQualifiedName,
+                    MethodName = method,
+                    Parameters = args,
+                };
+                string json = JsonConvert.SerializeObject(request);
+                byte[] bytes = Encoding.UTF8.GetBytes(json);
+                var writer = new BinaryWriter(client);
+                writer.Write(bytes.Length);
+                writer.Write(bytes);
+                await client.FlushAsync();
+
+                // receive response
+                var reader = new StreamReader(client);
+                string responseJson = await reader.ReadToEndAsync();
+                IpcResponse response = JsonConvert.DeserializeObject<IpcResponse>(responseJson);
+                if (response.Succeed)
+                {
+                    return ((JObject)response.Data).ToObject<TResult>();
+                }
+                else
+                {
+                    throw new InvalidOperationException(response.Failure);
+                }
+            }
+        }
     }
 }

src/JKang.IpcServiceFramework/IpcServiceHost.cs

@@ -1,12 +1,124 @@
-using System;
+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
 {
-    public static class IpcServiceHost
+    public class IpcServiceHost : IIpcServiceHost
     {
-        public static IIpcServiceHost Buid(IServiceProvider serviceProvider)
+        private readonly string _pipeName;
+        private readonly IServiceProvider _serviceProvider;
+        private readonly ILogger<IpcServiceHost> _logger;
+
+        public IpcServiceHost(string pipeName, IServiceProvider serviceProvider)
+        {
+            _pipeName = pipeName;
+            _serviceProvider = serviceProvider;
+            _logger = _serviceProvider.GetService<ILogger<IpcServiceHost>>();
+        }
+
+        public void Start()
+        {
+            using (var server = new NamedPipeServerStream(_pipeName, PipeDirection.InOut, 1))
+            using (var reader = new BinaryReader(server))
+            using (var writer = new StreamWriter(server))
+            {
+                while (true)
+                {
+                    _logger.LogInformation("IPC service started. Waiting for connection");
+                    server.WaitForConnection();
+
+                    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);
+                        }
+
+                        _logger.LogDebug("sending response...");
+                        string resultJson = JsonConvert.SerializeObject(response);
+                        writer.Write(resultJson);
+                        writer.Flush();
+                        server.Disconnect();
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, ex.Message);
+                        server.Disconnect();
+                    }
+                }
+            }
+        }
+
+        private static IpcResponse GetReponse(IpcRequest request, IServiceScope scope)
         {
-            throw new NotImplementedException();
+            var @interface = Type.GetType(request.InterfaceName);
+            if (@interface == null)
+            {
+                return IpcResponse.Fail($"Interface '{@interface}' not found.");
+            }
+
+            object service = scope.ServiceProvider.GetService(@interface);
+            if (service == null)
+            {
+                return IpcResponse.Fail($"No implementation of interface '{@interface}' found.");
+            }
+
+            MethodInfo method = service.GetType().GetMethod(request.MethodName);
+            if (method == null)
+            {
+                return IpcResponse.Fail($"Method '{request.MethodName}' not found in interface '{@interface}'.");
+            }
+
+            ParameterInfo[] paramInfos = method.GetParameters();
+            if (paramInfos.Length != request.Parameters.Length)
+            {
+                return IpcResponse.Fail($"Parameter mismatch.");
+            }
+
+            object[] args = new object[paramInfos.Length];
+            for (int i = 0; i < args.Length; i++)
+            {
+                if (request.Parameters[i].GetType() == paramInfos[i].ParameterType)
+                {
+                    args[i] = request.Parameters[i];
+                }
+                else if (request.Parameters[i] is JObject jObj)
+                {
+                    args[i] = jObj.ToObject(paramInfos[i].ParameterType);
+                }
+                else
+                {
+                    return IpcResponse.Fail($"Cannot convert value of parameter '{paramInfos[i].Name}'");
+                }
+            }
+
+            try
+            {
+                dynamic @return = (dynamic)method.Invoke(service, args);
+                return IpcResponse.Success(@return.Result); // TODO: handle non-waitable method
+            }
+            catch
+            {
+                return IpcResponse.Fail("Internal server error");
+            }
         }
     }
 }

src/JKang.IpcServiceFramework/IpcServiceHostBuilder.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace JKang.IpcServiceFramework
+{
+    public static class IpcServiceHostBuilder
+    {
+        public static IIpcServiceHost Buid(string pipeName, IServiceProvider serviceProvider)
+        {
+            return new IpcServiceHost(pipeName, serviceProvider);
+        }
+    }
+}

src/JKang.IpcServiceFramework/JKang.IpcServiceFramework.csproj

@@ -1,7 +1,13 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="2.0.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
+  </ItemGroup>
+
 </Project>