Merge pull request #28 from jacqueskang/specify-endpoint-contract

support specifying contract for each endpoint

Author: jacqueskang

README.md

@@ -2,11 +2,11 @@
 
 # IpcServiceFramework
 
-A .NET Core lightweight inter-process communication framework allowing invoking a service via named pipeline (in a similar way as WCF, which is currently unavailable for .NET Core).
+A .NET Core lightweight inter-process communication framework allowing invoking a service via named pipeline and/or TCP (in a similar way as WCF, which is currently unavailable for .NET Core).
 
 Support using primitive or complexe types in service contract.
 
-Support multi-threading on server side with configurable number of threads.
+Support multi-threading on server side with configurable number of threads (named pipeline endpoint only).
 
 [ASP.NET Core Dependency Injection framework](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection) friendly.
 
@@ -48,25 +48,28 @@ IpcServiceFramework is available via NuGet:
 ### Step 3 - Host the service in Console application
 
 ```csharp
-   class Program
+    class Program
     {
         static void Main(string[] args)
         {
             // configure DI
             IServiceCollection services = ConfigureServices(new ServiceCollection());
 
-            // run IPC service host
-            IpcServiceHostBuilder
-                .Buid("pipeName", services.BuildServiceProvider())
+            // build and run service host
+            new IpcServiceHostBuilder(services.BuildServiceProvider())
+                .AddNamedPipeEndpoint<IComputingService>(name: "endpoint1", pipeName: "pipeName")
+                .AddTcpEndpoint<IComputingService>(name: "endpoint2", ipEndpoint: IPAddress.Loopback, port: 45684)
+                .Build()
                 .Run();
         }
 
         private static IServiceCollection ConfigureServices(IServiceCollection services)
         {
             return services
-                .AddIpc(options =>
+                .AddIpc()
+                .AddNamedPipe(options =>
                 {
-                    options.ThreadCount = 4;
+                    options.ThreadCount = 2;
                 })
                 .AddService<IComputingService, ComputingService>();
         }
@@ -77,8 +80,11 @@ It's possible to host IPC service in web application, please check out the sampl
 ### Step 4 - Invoke the service from client process
 
 ```csharp
-    var proxy = new IpcServiceClient<IComputingService>("pipeName");
-    float result = await proxy.InvokeAsync(x => x.AddFloat(1.23f, 4.56f));
+    IpcServiceClient<IComputingService> client = new IpcServiceClientBuilder<IComputingService>()
+        .UseNamedPipe("pipeName") // or .UseTcp(IPAddress.Loopback, 45684) to invoke using TCP
+        .Build();
+
+    float result = await client.InvokeAsync(x => x.AddFloat(1.23f, 4.56f));
 ```
 
 __Please feel free to download, fork and/or provide any feedback!__

src/IpcServiceSample.ConsoleClient/Program.cs

@@ -18,25 +18,26 @@ private static async Task MainAsync(string[] args)
         {
             try
             {
-                IpcServiceClient<IComputingService> client = new IpcServiceClientBuilder<IComputingService>()
-                    // Comment in if you wish to use TCP instead
+                IpcServiceClient<IComputingService> computingClient = new IpcServiceClientBuilder<IComputingService>()
                     .UseNamedPipe("pipeName")
-                    // Comment out if you wish to use TCP instead
-                    // .UseTcp(IPAddress.Loopback, 45684)
+                    .Build();
+
+                IpcServiceClient<ISystemService> systemClient = new IpcServiceClientBuilder<ISystemService>()
+                    .UseTcp(IPAddress.Loopback, 45684)
                     .Build();
 
                 // test 1: call IPC service method with primitive types
-                float result1 = await client.InvokeAsync(x => x.AddFloat(1.23f, 4.56f));
+                float result1 = await computingClient.InvokeAsync(x => x.AddFloat(1.23f, 4.56f));
                 Console.WriteLine($"[TEST 1] sum of 2 floating number is: {result1}");
 
                 // test 2: call IPC service method with complex types
-                ComplexNumber result2 = await client.InvokeAsync(x => x.AddComplexNumber(
+                ComplexNumber result2 = await computingClient.InvokeAsync(x => x.AddComplexNumber(
                     new ComplexNumber(0.1f, 0.3f),
                     new ComplexNumber(0.2f, 0.6f)));
                 Console.WriteLine($"[TEST 2] sum of 2 complexe number is: {result2.A}+{result2.B}i");
 
                 // test 3: call IPC service method with an array of complex types
-                ComplexNumber result3 = await client.InvokeAsync(x => x.AddComplexNumbers(new[]
+                ComplexNumber result3 = await computingClient.InvokeAsync(x => x.AddComplexNumbers(new[]
                 {
                     new ComplexNumber(0.5f, 0.4f),
                     new ComplexNumber(0.2f, 0.1f),
@@ -45,20 +46,20 @@ private static async Task MainAsync(string[] args)
                 Console.WriteLine($"[TEST 3] sum of 3 complexe number is: {result3.A}+{result3.B}i");
 
                 // test 4: call IPC service method without parameter or return
-                await client.InvokeAsync(x => x.DoNothing());
+                await systemClient.InvokeAsync(x => x.DoNothing());
                 Console.WriteLine($"[TEST 4] invoked DoNothing()");
 
                 // test 5: call IPC service method with enum parameter
-                string text = await client.InvokeAsync(x => x.ConvertText("hEllO woRd!", TextStyle.Upper));
+                string text = await systemClient.InvokeAsync(x => x.ConvertText("hEllO woRd!", TextStyle.Upper));
                 Console.WriteLine($"[TEST 5] {text}");
 
                 // test 6: call IPC service method returning GUID
-                Guid generatedId = await client.InvokeAsync(x => x.GenerateId());
+                Guid generatedId = await systemClient.InvokeAsync(x => x.GenerateId());
                 Console.WriteLine($"[TEST 6] generated ID is: {generatedId}");
 
                 // test 7: call IPC service method with byte array
                 byte[] input = Encoding.UTF8.GetBytes("Test");
-                byte[] reversed = await client.InvokeAsync(x => x.ReverseBytes(input));
+                byte[] reversed = await systemClient.InvokeAsync(x => x.ReverseBytes(input));
                 Console.WriteLine($"[TEST 7] reversed bytes are: {Convert.ToBase64String(reversed)}");
 
             }

src/IpcServiceSample.ConsoleServer/ComputingService.cs

@@ -1,9 +1,6 @@
-using System;
-using System.Collections.Generic;
-using System.Globalization;
-using System.Linq;
-using IpcServiceSample.ServiceContracts;
+using IpcServiceSample.ServiceContracts;
 using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
 
 namespace IpcServiceSample.ConsoleServer
 {
@@ -26,7 +23,7 @@ public ComplexNumber AddComplexNumbers(IEnumerable<ComplexNumber> numbers)
         {
             _logger.LogInformation($"{nameof(AddComplexNumbers)} called.");
             var result = new ComplexNumber(0, 0);
-            foreach (var number in numbers)
+            foreach (ComplexNumber number in numbers)
             {
                 result = new ComplexNumber(result.A + number.A, result.B + number.B);
             }
@@ -38,31 +35,5 @@ public float AddFloat(float x, float y)
             _logger.LogInformation($"{nameof(AddFloat)} called.");
             return x + y;
         }
-
-        public string ConvertText(string text, TextStyle style)
-        {
-            switch (style)
-            {
-                case TextStyle.TitleCase:
-                    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(text);
-                case TextStyle.Upper:
-                    return CultureInfo.InvariantCulture.TextInfo.ToUpper(text);
-                default:
-                    return text;
-            }
-        }
-
-        public void DoNothing()
-        { }
-
-        public Guid GenerateId()
-        {
-            return Guid.NewGuid();
-        }
-
-        public byte[] ReverseBytes(byte[] input)
-        {
-            return input.Reverse().ToArray();
-        }
     }
 }

src/IpcServiceSample.ConsoleServer/Program.cs

@@ -1,23 +1,22 @@
-using System.Net;
-using IpcServiceSample.ServiceContracts;
+using IpcServiceSample.ServiceContracts;
 using JKang.IpcServiceFramework;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
+using System.Net;
 
 namespace IpcServiceSample.ConsoleServer
 {
     class Program
     {
         static void Main(string[] args)
         {
-            // build service provider
+            // configure DI
             IServiceCollection services = ConfigureServices(new ServiceCollection());
-            ServiceProvider serviceProvider = services.BuildServiceProvider();
 
-            // TODO start IPC service host
-            new IpcServiceHostBuilder(serviceProvider)
-                .AddNamedPipeEndpoint("endpoint1", "pipeName")
-                .AddTcpEndpoint("endpoint2", IPAddress.Loopback, 45684)
+            // build and run service host
+            new IpcServiceHostBuilder(services.BuildServiceProvider())
+                .AddNamedPipeEndpoint<IComputingService>("computingEndpoint", "pipeName")
+                .AddTcpEndpoint<ISystemService>("systemEndpoint", IPAddress.Loopback, 45684)
                 .Build()
                 .Run();
         }
@@ -37,7 +36,8 @@ private static IServiceCollection ConfigureServices(IServiceCollection services)
                 {
                     options.ThreadCount = 2;
                 })
-                .AddService<IComputingService, ComputingService>();
+                .AddService<IComputingService, ComputingService>()
+                .AddService<ISystemService, SystemService>();
 
             return services;
         }

src/IpcServiceSample.ConsoleServer/SystemService.cs

@@ -0,0 +1,36 @@
+using IpcServiceSample.ServiceContracts;
+using System;
+using System.Globalization;
+using System.Linq;
+
+namespace IpcServiceSample.ConsoleServer
+{
+    public class SystemService : ISystemService
+    {
+        public string ConvertText(string text, TextStyle style)
+        {
+            switch (style)
+            {
+                case TextStyle.TitleCase:
+                    return CultureInfo.InvariantCulture.TextInfo.ToTitleCase(text);
+                case TextStyle.Upper:
+                    return CultureInfo.InvariantCulture.TextInfo.ToUpper(text);
+                default:
+                    return text;
+            }
+        }
+
+        public void DoNothing()
+        { }
+
+        public Guid GenerateId()
+        {
+            return Guid.NewGuid();
+        }
+
+        public byte[] ReverseBytes(byte[] input)
+        {
+            return input.Reverse().ToArray();
+        }
+    }
+}

src/IpcServiceSample.ServiceContracts/IComputingService.cs

@@ -8,10 +8,6 @@ public interface IComputingService
         float AddFloat(float x, float y);
         ComplexNumber AddComplexNumber(ComplexNumber x, ComplexNumber y);
         ComplexNumber AddComplexNumbers(IEnumerable<ComplexNumber> numbers);
-        void DoNothing();
-        string ConvertText(string text, TextStyle style);
-        Guid GenerateId();
-        byte[] ReverseBytes(byte[] input);
     }
 
     public class ComplexNumber

src/IpcServiceSample.ServiceContracts/ISystemService.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace IpcServiceSample.ServiceContracts
+{
+    public interface ISystemService
+    {
+        void DoNothing();
+        string ConvertText(string text, TextStyle style);
+        Guid GenerateId();
+        byte[] ReverseBytes(byte[] input);
+    }
+}

src/IpcServiceSample.WebServer/Program.cs

@@ -1,8 +1,10 @@
-using JKang.IpcServiceFramework;
+using IpcServiceSample.ServiceContracts;
+using JKang.IpcServiceFramework;
 using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using System;
+using System.Net;
 using System.Threading;
 
 namespace IpcServiceSample.WebServer
@@ -23,7 +25,8 @@ private static void StartIpcService(object state)
         {
             var serviceProvider = state as IServiceProvider;
             new IpcServiceHostBuilder(serviceProvider)
-                .AddNamedPipeEndpoint("ep1", "pipeName")
+                .AddNamedPipeEndpoint<IComputingService>("computingEndpoint", "pipeName")
+                .AddTcpEndpoint<ISystemService>("systemEndpoint", IPAddress.Loopback, 45684)
                 .Build()
                 .Run();
         }

src/IpcServiceSample.WebServer/Startup.cs

@@ -16,7 +16,7 @@ public void ConfigureServices(IServiceCollection services)
                 .AddIpc()
                 .AddNamedPipe()
                 .AddService<IComputingService, ComputingService>()
-                ;
+                .AddService<ISystemService, SystemService>();
         }
 
         public void Configure(IApplicationBuilder app, IHostingEnvironment env)

src/JKang.IpcServiceFramework.Client/IpcServiceClient.cs

@@ -78,7 +78,6 @@ private static IpcRequest GetRequest(Expression exp, MyInterceptor interceptor)
 
             return new IpcRequest
             {
-                InterfaceName = typeof(TInterface).AssemblyQualifiedName,
                 MethodName = interceptor.LastInvocation.Method.Name,
                 Parameters = interceptor.LastInvocation.Arguments,
             };