NetConduit.Transit.Message 3.0.1

NetConduit

Transport-agnostic stream multiplexer for .NET — Multiple virtual channels over a single bidirectional stream.

N streams → 1 stream (mux) → N streams (demux)

Features

• Multiple channels — Many logical streams over one connection
• Credit-based backpressure — Flow control prevents overwhelming receivers
• Priority queuing — Higher priority frames sent first
• Auto-reconnection — Channel state restored after disconnect
• Native AOT — No reflection in core library
• Zero dependencies — Only BCL types
• Modern .NET — Targets .NET 8, 9, and 10

Quick Start

dotnet add package NetConduit
dotnet add package NetConduit.Transport.Tcp
dotnet add package NetConduit.Transit.Message

using NetConduit;
using NetConduit.Transport.Tcp;
using NetConduit.Transit.Message;
using System.Text.Json.Serialization;

public record ChatMessage(string User, string Text);

[JsonSerializable(typeof(ChatMessage))]
public partial class ChatContext : JsonSerializerContext { }

// Server
var listener = new TcpListener(IPAddress.Any, 5000);
listener.Start();
await using var server = StreamMultiplexer.Create(TcpMultiplexer.CreateServerOptions(listener));
server.Start();
await server.WaitForReadyAsync();

await using var transit = await server.AcceptMessageTransitAsync("chat", ChatContext.Default.ChatMessage);
await foreach (var msg in transit.ReceiveAllAsync())
    Console.WriteLine($"[{msg.User}] {msg.Text}");

// Client
await using var client = StreamMultiplexer.Create(TcpMultiplexer.CreateOptions("localhost", 5000));
client.Start();
await client.WaitForReadyAsync();

await using var transit = await client.OpenMessageTransitAsync("chat", ChatContext.Default.ChatMessage);
await transit.SendAsync(new ChatMessage("Alice", "Hello!"));

Packages

Architecture

┌──────────────────────────────────────────────────────────────────────────────┐
│  Application                                                                 │
├──────────────────────────────────────────────────────────────────────────────┤
│  Transit Layer (Optional)                                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────────────┐  ┌─────────────┐  │
│  │MessageTransit│  │ DeltaMessageTransit │  │DuplexStreamTransit│  │StreamTransit│  │
│  └──────────────┘  └──────────────┘  └───────────────────┘  └─────────────┘  │
├──────────────────────────────────────────────────────────────────────────────┤
│  NetConduit Core                                                             │
│  - Frame encoding/decoding                                                   │
│  - Channel management                                                        │
│  - Credit-based backpressure                                                 │
│  - Priority queuing                                                          │
│  - Auto-reconnection                                                         │
├──────────────────────────────────────────────────────────────────────────────┤
│  Transport Layer (Pluggable)                                                 │
│  ┌─────┐  ┌─────────┐  ┌─────┐  ┌─────┐  ┌──────┐                            │
│  │ TCP │  │WebSocket│  │ UDP │  │ IPC │  │ QUIC │                            │
│  └─────┘  └─────────┘  └─────┘  └─────┘  └──────┘                            │
└──────────────────────────────────────────────────────────────────────────────┘

Samples

dotnet run --project samples/GroupChatSample -- server tcp 5000
dotnet run --project samples/GroupChatSample -- client tcp 5000 127.0.0.1 Alice

Documentation

Full documentation at docs/:

• Getting Started
• Transports — TCP, WebSocket, UDP, IPC, QUIC
• Transits — MessageTransit, DeltaMessageTransit, DuplexStream, Stream
• Concepts — Channels, backpressure, priority, reconnection
• API Reference

Building

dotnet build
dotnet test

License

See LICENSE.