handle primitive type conversions

Author: jacqueskang

README.md

@@ -13,104 +13,64 @@ A .NET Core lightweight inter-process communication framework allowing invoking
 
 1. Service contract
 ```csharp
-using System.Threading.Tasks;
-
-namespace IpcServiceSample.Contracts
-{
-    public interface IMyIpcService
-    {
-        Task<MyResponse> GetDataAsync(MyRequest request, bool iAmHandsome);
-    }
-
-    public class MyRequest
+    public interface IComputingService
     {
-        public string Message { get; set; }
+        float Add(float x, float y);
     }
-
-    public class MyResponse
-    {
-        public string Message { get; set; }
-    }
-}
 ```
 
 2. Client side
 
 ```csharp
-using IpcServiceSample.Contracts;
-using JKang.IpcServiceFramework;
-using System;
-using System.Threading.Tasks;
-
-namespace IpcServiceSample.ConsoleClient
-{
-    // implement proxy
-    class MyClient : IpcServiceClient<IMyIpcService>, IMyIpcService
+    class ComputingServiceClient : IpcServiceClient<IComputingService>, IComputingService
     {
-        public MyClient(string pipeName)
+        public ComputingServiceClient(string pipeName)
             : base(pipeName)
         { }
 
-        public Task<MyResponse> GetDataAsync(MyRequest request, bool iAmHandsome)
+        public float Add(float x, float y)
         {
-            return InvokeAsync<MyResponse>(nameof(GetDataAsync), request, iAmHandsome);
+            return Invoke<float>(nameof(Add), x, y);
         }
     }
+```
 
-    class Program
+3. Server side
+
+```csharp
+	// service implementation
+    public class ComputingService : IComputingService
     {
-        static void Main(string[] args)
+        private readonly ILogger<ComputingService> _logger;
+
+        public ComputingService(ILogger<ComputingService> logger)
         {
-            MainAsync().Wait();
+            _logger = logger;
         }
 
-        private static async Task MainAsync()
+        public float Add(float x, float y)
         {
-            Console.WriteLine("Invoking IpcService...");
-            var client = new MyClient("pipeName");
-            MyResponse response = await client.GetDataAsync(new MyRequest
-            {
-                Message = "Hello"
-            }, iAmHandsome: true);
-
-            Console.WriteLine($"Received response: '{response.Message}'");
+            _logger.LogInformation($"{nameof(Add)} called.");
+            return x + y;
         }
     }
-}
 ```
 
-3. Server side
-
 ```csharp
-using IpcServiceSample.Contracts;
-using JKang.IpcServiceFramework;
-using Microsoft.Extensions.DependencyInjection;
-using System;
-
-namespace IpcServiceSample.ConsoleServer
-{
-    // service implementation
-    public class MyIpcService : IMyIpcService
-    {
-        public Task<MyResponse> GetDataAsync(MyRequest request, bool iAmHandsome)
-        {
-            var response = new MyResponse
-            {
-                Message = $"What you said '{request.Message}' is {(iAmHandsome ? "correct." : "wrong")}"
-            };
-            return Task.FromResult(response);
-        }
-    }
-
-    class Program
+	// hosting in Console application
+   class Program
     {
         static void Main(string[] args)
         {
             // build service provider
             IServiceCollection services = ConfigureServices(new ServiceCollection());
             ServiceProvider serviceProvider = services.BuildServiceProvider();
 
-            // start IPC service host
+            // configure console logging
+            serviceProvider.GetRequiredService<ILoggerFactory>()
+                .AddConsole(LogLevel.Debug);
+
+            // TODO start IPC service host
             IpcServiceHostBuilder
                 .Buid("pipeName", serviceProvider as IServiceProvider)
                 .Start();
@@ -124,13 +84,12 @@ namespace IpcServiceSample.ConsoleServer
 
             services
                 .AddIpc()
-                .AddService<IMyIpcService, MyIpcService>()
+                .AddService<IComputingService, ComputingService>()
                 ;
 
             return services;
         }
     }
-}
 ```
 
 I'll publish a NuGet package soon.

src/IpcServiceSample.ConsoleClient/ComputingServiceClient.cs

@@ -0,0 +1,17 @@
+using IpcServiceSample.ServiceContracts;
+using JKang.IpcServiceFramework;
+
+namespace IpcServiceSample.ConsoleClient
+{
+    class ComputingServiceClient : IpcServiceClient<IComputingService>, IComputingService
+    {
+        public ComputingServiceClient(string pipeName)
+            : base(pipeName)
+        { }
+
+        public float Add(float x, float y)
+        {
+            return Invoke<float>(nameof(Add), x, y);
+        }
+    }
+}

src/IpcServiceSample.ConsoleClient/MyClient.cs

@@ -13,14 +13,19 @@ static void Main(string[] args)
 
         private static async Task MainAsync()
         {
-            Console.WriteLine("Invoking IpcService...");
-            var client = new MyClient("pipeName");
-            MyResponse response = await client.GetDataAsync(new MyRequest
+            try
             {
-                Message = "Hello"
-            }, iAmHandsome: true);
+                Console.WriteLine("Invoking IpcService...");
+                var client = new ComputingServiceClient("pipeName");
+                float x = 1.23f, y = 4.56f;
+                float sum = client.Add(x, y);
 
-            Console.WriteLine($"Received response: {response.Message}");
+                Console.WriteLine($"{x} + {y} = {sum}");
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine(ex);
+            }
         }
     }
 }

src/IpcServiceSample.ConsoleClient/Program.cs

@@ -0,0 +1,21 @@
+using IpcServiceSample.ServiceContracts;
+using Microsoft.Extensions.Logging;
+
+namespace IpcServiceSample.ConsoleServer
+{
+    public class ComputingService : IComputingService
+    {
+        private readonly ILogger<ComputingService> _logger;
+
+        public ComputingService(ILogger<ComputingService> logger)
+        {
+            _logger = logger;
+        }
+
+        public float Add(float x, float y)
+        {
+            _logger.LogInformation($"{nameof(Add)} called.");
+            return x + y;
+        }
+    }
+}

src/IpcServiceSample.ConsoleServer/ComputingService.cs

@@ -32,7 +32,7 @@ private static IServiceCollection ConfigureServices(IServiceCollection services)
 
             services
                 .AddIpc()
-                .AddService<IMyIpcService, MyIpcService>()
+                .AddService<IComputingService, ComputingService>()
                 ;
 
             return services;

src/IpcServiceSample.ConsoleServer/MyIpcService.cs

@@ -0,0 +1,7 @@
+namespace IpcServiceSample.ServiceContracts
+{
+    public interface IComputingService
+    {
+        float Add(float x, float y);
+    }
+}