Added Async methods implementation for contracts

Author: adospace

src/IpcServiceSample.ConsoleClient/Program.cs

@@ -88,6 +88,14 @@ private static async Task RunTestsAsync(CancellationToken cancellationToken)
             // test 9: call slow IPC service method 
             await systemClient.InvokeAsync(x => x.SlowOperation(), cancellationToken);
             Console.WriteLine($"[TEST 9] Called slow operation");
+
+            // test 10: call async server method
+            await computingClient.InvokeAsync(x => x.MethodAsync());
+            Console.WriteLine($"[TEST 10] Called async method");
+
+            // test 11: call async server function
+            int sum = await computingClient.InvokeAsync(x => x.SumAsync(1, 1));
+            Console.WriteLine($"[TEST 11] Called async function: {sum}");
         }
     }
 }

src/IpcServiceSample.ConsoleServer/ComputingService.cs

@@ -1,6 +1,7 @@
 using IpcServiceSample.ServiceContracts;
 using Microsoft.Extensions.Logging;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace IpcServiceSample.ConsoleServer
 {
@@ -35,5 +36,15 @@ public float AddFloat(float x, float y)
             _logger.LogInformation($"{nameof(AddFloat)} called.");
             return x + y;
         }
+
+        public Task MethodAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task<int> SumAsync(int x, int y)
+        {
+            return Task.FromResult(x + y);
+        }
     }
 }

src/IpcServiceSample.ServiceContracts/IComputingService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace IpcServiceSample.ServiceContracts
 {
@@ -8,6 +9,9 @@ public interface IComputingService
         float AddFloat(float x, float y);
         ComplexNumber AddComplexNumber(ComplexNumber x, ComplexNumber y);
         ComplexNumber AddComplexNumbers(IEnumerable<ComplexNumber> numbers);
+
+        Task MethodAsync();
+        Task<int> SumAsync(int x, int y);
     }
 
     public class ComplexNumber

src/JKang.IpcServiceFramework.Client/IpcServiceClient.cs

@@ -63,6 +63,46 @@ public async Task<TResult> InvokeAsync<TResult>(Expression<Func<TInterface, TRes
             }
         }
 
+        public async Task InvokeAsync(Expression<Func<TInterface, Task>> exp,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            IpcRequest request = GetRequest(exp, new MyInterceptor<Task>());
+            IpcResponse response = await GetResponseAsync(request, cancellationToken);
+
+            if (response.Succeed)
+            {
+                return;
+            }
+            else
+            {
+                throw new InvalidOperationException(response.Failure);
+            }
+        }
+
+        public async Task<TResult> InvokeAsync<TResult>(Expression<Func<TInterface, Task<TResult>>> exp,
+            CancellationToken cancellationToken = default(CancellationToken))
+        {
+            IpcRequest request = GetRequest(exp, new MyInterceptor<Task<TResult>>());
+            IpcResponse response = await GetResponseAsync(request, cancellationToken);
+
+            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);
+            }
+        }
+
+
         private static IpcRequest GetRequest(Expression exp, MyInterceptor interceptor)
         {
             if (!(exp is LambdaExpression lamdaExp))

src/JKang.IpcServiceFramework.Server/IpcServiceEndpoint.cs

@@ -58,7 +58,7 @@ protected async Task ProcessAsync(Stream server, ILogger logger, CancellationTok
                     IpcResponse response;
                     using (IServiceScope scope = ServiceProvider.CreateScope())
                     {
-                        response = GetReponse(request, scope);
+                        response = await GetReponse(request, scope);
                     }
 
                     cancellationToken.ThrowIfCancellationRequested();
@@ -75,7 +75,7 @@ protected async Task ProcessAsync(Stream server, ILogger logger, CancellationTok
             }
         }
 
-        protected IpcResponse GetReponse(IpcRequest request, IServiceScope scope)
+        protected async Task<IpcResponse> GetReponse(IpcRequest request, IServiceScope scope)
         {
             object service = scope.ServiceProvider.GetService<TContract>();
             if (service == null)
@@ -127,11 +127,15 @@ protected IpcResponse GetReponse(IpcRequest request, IServiceScope scope)
                 {
                     method = method.MakeGenericMethod(request.GenericArguments);
                 }
-                
+
                 object @return = method.Invoke(service, args);
+
                 if (@return is Task)
                 {
-                    throw new NotImplementedException();
+                    await (Task)@return;
+
+                    var resultProperty = @return.GetType().GetProperty("Result");
+                    return IpcResponse.Success(resultProperty?.GetValue(@return));
                 }
                 else
                 {