A simple, easy to use, strongly-typed, async wrapper around .NET named pipes.
Features
Create named pipe servers that can handle multiple client connections simultaneously.
Send strongly-typed messages between clients and servers: any serializable .NET object can be sent over a pipe and will be automatically serialized/deserialized, including cyclical references and complex object graphs.
Async
Requires .NET Standard 2.0
Supports large messages - up to 300 MiB.
Server restart automatically
Automatically wait for the release of the pipe for the server, if it is already in use
Automatically waiting for a server pipe creating when client connecting
Automatic reconnect with a given interval and at each client.WriteAsync, if necessary
Supports variable formatters, default - BinaryFormatter which uses System.Runtime.Serialization.BinaryFormatter inside
Also available ready formatters in separate nuget packages: H.Formatters.Newtonsoft.Json, H.Formatters.System.Text.Json and H.Formatters.Ceras
Supports PipeAccessRule's(see H.Pipes.AccessControl nuget package) or more complex code to access using the PipeServer.PipeStreamInitializeAction property
Nuget
// All clients and servers that do not need support AccessControl.
Install-Package H.Pipes
// Servers that need support AccessControl.
Install-Package H.Pipes.AccessControl
// If you want to transfer any data that can be serialized/deserialized in json using Newtonsoft.Json.
Install-Package H.Formatters.Newtonsoft.Json
// If you want to transfer any data that can be serialized/deserialized in json using System.Text.Json.
Install-Package H.Formatters.System.Text.Json
// If you want to transfer any data that can be serialized/deserialized in binary using Ceras.
Install-Package H.Formatters.Ceras
Usage
Server:
await using var server = new PipeServer<MyMessage>(pipeName);
server.ClientConnected += async (o, args) =>
{
Console.WriteLine($"Client {args.Connection.PipeName} is now connected!");
await args.Connection.WriteAsync(new MyMessage
{
Text = "Welcome!"
});
};
server.ClientDisconnected += (o, args) =>
{
Console.WriteLine($"Client {args.Connection.PipeName} disconnected");
};
server.MessageReceived += (sender, args) =>
{
Console.WriteLine($"Client {args.Connection.PipeName} says: {args.Message}");
};
server.ExceptionOccurred += (o, args) => OnExceptionOccurred(args.Exception);
await server.StartAsync();
await Task.Delay(Timeout.InfiniteTimeSpan);
Client:
await using var client = new PipeClient<MyMessage>(pipeName);
client.MessageReceived += (o, args) => Console.WriteLine("MessageReceived: " + args.Message);
client.Disconnected += (o, args) => Console.WriteLine("Disconnected from server");
client.Connected += (o, args) => Console.WriteLine("Connected to server");
client.ExceptionOccurred += (o, args) => OnExceptionOccurred(args.Exception);
await client.ConnectAsync();
await client.WriteAsync(new MyMessage
{
Text = "Hello!",
});
await Task.Delay(Timeout.InfiniteTimeSpan);
Notes:
To use the server inside the WinForms/WPF/Other UI application, use Task.Run() or any alternative.
Be careful and call Dispose before closing the program/after the end of use.
Pipes are system resources and you might have problems restarting the server if you don't properly clean up the resources.
using H.Formatters;
await using var server = new PipeServer<MyMessage>(pipeName, formatter: new NewtonsoftJsonFormatter());
await using var client = new PipeClient<MyMessage>(pipeName, formatter: new NewtonsoftJsonFormatter());
Access Control
:warning: Note: this is only available for the Windows platform
Install-Package H.Pipes.AccessControl
using System.IO.Pipes;
using H.Pipes.AccessControl;
await using var server = new PipeServer<string>(pipeName);
// You can set PipeSecurity
var pipeSecurity = new PipeSecurity();
pipeSecurity.AddAccessRule(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), PipeAccessRights.ReadWrite, AccessControlType.Allow));
server.SetPipeSecurity(pipeSecurity);
// or just add AccessRule's (Please be careful, the server will only consider AccessRules from the last call AddAccessRules())
server.AddAccessRules(new PipeAccessRule(new SecurityIdentifier(WellKnownSidType.BuiltinUsersSid, null), PipeAccessRights.ReadWrite, AccessControlType.Allow));
// or just
server.AllowUsersReadWrite();
Encryption
:warning: Note: this is only available for the Windows platform
Install-Package H.Formatters.Inferno
using H.Formatters;
await using var server = new PipeServer<MyMessage>(pipeName, formatter: new SystemTextJsonFormatter());
server.EnableEncryption();
await using var client = new PipeClient<MyMessage>(pipeName, formatter: new SystemTextJsonFormatter());
client.EnableEncryption();
await client.ConnectAsync(source.Token).ConfigureAwait(false);
// Waits for key exchange.
await client.Connection!.WaitExchangeAsync();
server.ClientConnected += async (_, args) =>
{
// Waits for key exchange.
await args.Connection.WaitExchangeAsync();
await args.Connection.WriteAsync(new MyMessage
{
Text = "Welcome!"
}, source.Token).ConfigureAwait(false);
};
GetImpersonationUserName
server.ClientConnected += async (o, args) =>
{
var name = args.Connection.GetImpersonationUserName();
Console.WriteLine($"Client {name} is now connected!");
};
Inter-process communication
I recommend that you take a look at my other library if you plan on doing IPC.
It is based on this library, but provides an IPC implementation based on C# interfaces.
It supports remote method invocation, asynchronous methods, cancellation via CancellationToken, events, and so on.
