supporting method returning void

Author: jacqueskang

src/IpcServiceSample.ConsoleClient/ComputingServiceClient.cs

@@ -9,14 +9,13 @@ public ComputingServiceClient(string pipeName)
             : base(pipeName)
         { }
 
-        public ComplexNumber AddComplexNumber(ComplexNumber x, ComplexNumber y)
-        {
-            return Invoke<ComplexNumber>(nameof(AddComplexNumber), x, y);
-        }
+        public ComplexNumber AddComplexNumber(ComplexNumber x, ComplexNumber y) 
+            => Invoke<ComplexNumber>(nameof(AddComplexNumber), x, y);
 
         public float AddFloat(float x, float y)
-        {
-            return Invoke<float>(nameof(AddFloat), x, y);
-        }
+            => Invoke<float>(nameof(AddFloat), x, y);
+
+        public void DoNothing()
+            => Invoke(nameof(DoNothing));
     }
 }

src/IpcServiceSample.ConsoleClient/Program.cs

@@ -21,6 +21,7 @@ private static async Task MainAsync()
                 float result1 = client.AddFloat(1.23f, 4.56f);
                 Console.WriteLine($"sum of 2 floating number is: {result1}");
 
+                client.DoNothing();
                 ComplexNumber result2 = client.AddComplexNumber(
                     new ComplexNumber(0.1f, 0.3f),
                     new ComplexNumber(0.2f, 0.6f));

src/IpcServiceSample.ConsoleServer/ComputingService.cs

@@ -23,5 +23,8 @@ public float AddFloat(float x, float y)
             _logger.LogInformation($"{nameof(AddFloat)} called.");
             return x + y;
         }
+
+        public void DoNothing()
+        { }
     }
 }

src/IpcServiceSample.ServiceContracts/IComputingService.cs

@@ -5,6 +5,8 @@ public interface IComputingService
         float AddFloat(float x, float y);
 
         ComplexNumber AddComplexNumber(ComplexNumber x, ComplexNumber y);
+
+        void DoNothing();
     }
 
     public class ComplexNumber

src/JKang.IpcServiceFramework.Client/IpcServiceClient.cs

@@ -14,11 +14,11 @@ public abstract class IpcServiceClient<TInterface>
         private readonly IIpcMessageSerializer _serializer;
         private readonly IValueConverter _converter;
 
-        public IpcServiceClient(string pipeName)
+        protected IpcServiceClient(string pipeName)
             : this(pipeName, new DefaultIpcMessageSerializer(), new DefaultValueConverter())
         { }
 
-        public IpcServiceClient(string pipeName,
+        protected IpcServiceClient(string pipeName,
             IIpcMessageSerializer serializer,
             IValueConverter converter)
         {
@@ -27,12 +27,50 @@ public IpcServiceClient(string pipeName,
             _converter = converter;
         }
 
-        public TResult Invoke<TResult>(string method, params object[] args)
+        protected TResult Invoke<TResult>(string method, params object[] args)
         {
-            return InvokeAsync<TResult>(method, args).Result;
+            IpcRequest request = CreateRequest(method, args);
+            IpcResponse response = GetResponseAsync(request).Result;
+
+            if (response.Succeed)
+            {
+                if (_converter.TryConvert(response.Data, typeof(TResult), out object @return))
+                {
+                    return (TResult)@return;
+                }
+                else
+                {
+                    throw new InvalidOperationException($"Unable to convert returned value to '{typeof(TResult).Name}'.");
+                }
+            }
+            else
+            {
+                throw new InvalidOperationException(response.Failure);
+            }
+        }
+
+        protected void Invoke(string method, params object[] args)
+        {
+            IpcRequest request = CreateRequest(method, args);
+            IpcResponse response = GetResponseAsync(request).Result;
+
+            if (!response.Succeed)
+            {
+                throw new InvalidOperationException(response.Failure);
+            }
+        }
+
+        private static IpcRequest CreateRequest(string method, object[] args)
+        {
+            return new IpcRequest
+            {
+                InterfaceName = typeof(TInterface).AssemblyQualifiedName,
+                MethodName = method,
+                Parameters = args,
+            };
         }
 
-        public async Task<TResult> InvokeAsync<TResult>(string method, params object[] args)
+        private async Task<IpcResponse> GetResponseAsync(IpcRequest request)
         {
             using (var client = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.None))
             using (var writer = new IpcWriter(client, _serializer))
@@ -41,30 +79,10 @@ public async Task<TResult> InvokeAsync<TResult>(string method, params object[] a
                 await client.ConnectAsync();
 
                 // send request
-                writer.Write(new IpcRequest
-                {
-                    InterfaceName = typeof(TInterface).AssemblyQualifiedName,
-                    MethodName = method,
-                    Parameters = args,
-                });
+                writer.Write(request);
 
                 // receive response
-                IpcResponse response = reader.ReadIpcResponse();
-                if (response.Succeed)
-                {
-                    if (_converter.TryConvert(response.Data, typeof(TResult), out object @return))
-                    {
-                        return (TResult)@return;
-                    }
-                    else
-                    {
-                        throw new InvalidOperationException($"Unable to convert returned value to '{typeof(TResult).Name}'.");
-                    }
-                }
-                else
-                {
-                    throw new InvalidOperationException(response.Failure);
-                }
+                return reader.ReadIpcResponse();
             }
         }
     }