https://github.com/dvoaviarison/fast-ipc
Simple, super fast, typed and event driven style inter-process communication .Net library (on the same machine)
https://github.com/dvoaviarison/fast-ipc
bus communication core cross-platform csharp csharp-library dotnet event fast inter-process ipc message nuget-package process publishing subscribe
Last synced: 3 months ago
JSON representation
Simple, super fast, typed and event driven style inter-process communication .Net library (on the same machine)
- Host: GitHub
- URL: https://github.com/dvoaviarison/fast-ipc
- Owner: dvoaviarison
- License: other
- Created: 2018-09-22T12:48:44.000Z (over 6 years ago)
- Default Branch: master
- Last Pushed: 2021-09-11T05:01:52.000Z (over 3 years ago)
- Last Synced: 2025-02-02T06:31:46.852Z (3 months ago)
- Topics: bus, communication, core, cross-platform, csharp, csharp-library, dotnet, event, fast, inter-process, ipc, message, nuget-package, process, publishing, subscribe
- Language: C#
- Homepage:
- Size: 161 KB
- Stars: 25
- Watchers: 2
- Forks: 4
- Open Issues: 0
-
Metadata Files:
- Readme: readme.md
- License: LICENSE.txt
Awesome Lists containing this project
README
[](https://ci.appveyor.com/project/dvoaviarison/fast-ipc/branch/master)
# Fast IPC
Fast IPC is an open source .Net library that supports typed messages and brings inter-process communication at a higher level for better usability.
It includes:
- Inter process communication layer using named pipes. It supports smart generation of pipe name in case of parent/child processes. Other means of communication are going to be supported in the near future
- Super fast serialization using protobuf
- Typed event driven syntax using internally .Net built-in event capability and exposing simple api such as `Subscribe` and `Publish`
## Get started
To make two processes communicate, all you need is to create an IPC bus in each process, then listen/publish on that bus, as follows:
**Define your messages**: All messages only need to inherit from `Message` and be a `ProtoContract` as follows:
```csharp
[ProtoContract]
public class Ping : Message { }
[ProtoContract]
public class Pong : Message { }
```
**ProcessA**: One process has to be described as `In` (see pipe name declaration)
```csharp
static void Main(string[] args) {
var pipeName = new SimpleStringPipeName(
name: "Example",
side: Side.In /* Optional */);;
var bus = new NamedPipeBus(pipeName: pipeName);
new ProcessAHost(bus);
...
}
```
```csharp
public class ProcessAHost : IHandleMessage {
private readonly IBus _bus;
public ProcessAsHost(IBus bus) {
_bus = bus;
_bus.Subscribe(this);
}
public void Handle(Message.Message msg) {
HandleInternal((dynamic)msg);
}
private void HandleInternal(Ping msg) {
Console.WriteLine("Received a ping, sending a pong");
_bus.Publish(new Pong());
}
private void HandleInternal(Pong msg) {
Console.WriteLine("Received a pong");
}
}
```
**ProcessB**: The other has to be described as `Out` (see pipe name declaration)
```csharp
static void Main(string[] args) {
var pipeName = new SimpleStringPipeName(
name: "Example",
side: Side.Out);
var bus = new NamedPipeBus(pipeName: pipeName);
new ProcessBHost(bus);
...
}
```
```csharp
public class ProcessBHost : IHandleMessage {
private readonly IBus _bus;
public ProcessBHost(IBus bus) {
_bus = bus;
_bus.Subscribe(this);
}
public void Handle(Message.Message msg) {
HandleInternal((dynamic)msg);
}
private void HandleInternal(Ping msg) {
Console.WriteLine("Received a ping, sending a pong");
_bus.Publish(new Pong());
}
private void HandleInternal(Pong msg) {
Console.WriteLine("Received a pong");
}
}
```
And voila! ProcessA and ProcessB are communicating
Working examples are available in `src` folder. We also have straightforward example using the [nuget package](https://www.nuget.org/packages/fastipc) : [HERE](https://github.com/dvoaviarison/fastipc-example)
## Contribute
This project is open source. Fork then PR!
For now we are using named pipes with limitation to 2 processes communicating.
We want to introduce TCP and enable multi-tier IPC.
## Compatibility
- .Net Framework >= net40
- .Net Standard >= netstandard2.0