Faster.Transport 0.0.21

🚀 Faster.Transport — High-Performance Transport Framework for .NET

Unified Real-Time Transport Layer for .NET 6–9 Applications
The fastest way to build zero-copy, low-latency, full-duplex communication across TCP, UDP, IPC, and In-Process backends.

Faster.Transport delivers a unified abstraction — IParticle — that powers all modes:

• 🧠 Inproc – ultra-fast in-memory messaging within one process
• 🧩 IPC – shared-memory communication across processes
• ⚡ TCP – reliable, framed, full-duplex network transport
• 📡 UDP – lightweight, multicast-capable datagram transport

✅ All transport modes share:

• Unified async + sync APIs
• Zero-allocation send/receive
• Zero-copy buffer reuse
• Consistent event-driven model

🧱 Architecture Overview

🧩 IParticle — Unified Transport Interface

Every transport implements the same high-performance contract:

public interface IParticle : IDisposable
{
    Action<IParticle, ReadOnlyMemory<byte>>? OnReceived { get; set; }
    Action<IParticle>? OnDisconnected { get; set; }
    Action<IParticle>? OnConnected { get; set; }

    ValueTask SendAsync(ReadOnlyMemory<byte> payload);
    void Send(ReadOnlySpan<byte> payload);
}

All modes (TCP, UDP, IPC, Inproc) share this exact API and semantics.

⚙️ Builders Overview

There are two primary builders:

Both share the same fluent configuration API.

⚡ TCP Examples

🧱 TCP Server (Reactor)

var server = new ReactorBuilder()
    .UseMode(TransportMode.Tcp)
    .WithLocal(new IPEndPoint(IPAddress.Any, 9500))
    .OnConnected(p => Console.WriteLine("🟢 Client connected"))
    .OnReceived((p, msg) =>
    {
        Console.WriteLine($"Server received: {Encoding.UTF8.GetString(msg.Span)}");
        p.Send("Echo"u8.ToArray());
    })
    .Build();

server.Start();
Console.WriteLine("✅ TCP server running on port 9500");

⚙️ TCP Client

var client = new ParticleBuilder()
    .UseMode(TransportMode.Tcp)
    .WithRemote(new IPEndPoint(IPAddress.Loopback, 9500))
    .OnConnected(p => Console.WriteLine("✅ Connected to TCP server"))
    .OnReceived((p, msg) =>
        Console.WriteLine($"📩 {Encoding.UTF8.GetString(msg.Span)}"))
    .Build();

await client.SendAsync("Hello TCP!"u8.ToArray());

💡 ReactorBuilder manages client lifetimes; each new connection spawns a dedicated IParticle.

📡 UDP Example (Full Duplex)

var port = 9700;

var udp = new ParticleBuilder()
    .UseMode(TransportMode.Udp)
    .WithLocal(new IPEndPoint(IPAddress.Any, port))
    .WithRemote(new IPEndPoint(IPAddress.Loopback, port))
    .AllowBroadcast(true)
    .OnConnected(p => Console.WriteLine("📡 UDP ready"))
    .OnReceived((p, msg) =>
        Console.WriteLine($"📨 {Encoding.UTF8.GetString(msg.Span)}"))
    .Build();

await udp.SendAsync("Ping via UDP!"u8.ToArray());

🌍 UDP Multicast Example

var group = IPAddress.Parse("239.0.0.123");
var port = 9700;

var peer = new ParticleBuilder()
    .UseMode(TransportMode.Udp)
    .WithMulticast(group, port, disableLoopback: false)
    .OnConnected(p => Console.WriteLine("✅ Joined multicast group"))
    .OnReceived((p, msg) =>
        Console.WriteLine($"📩 {Encoding.UTF8.GetString(msg.Span)}"))
    .Build();

await peer.SendAsync("Hello multicast group!"u8.ToArray());

💡 Use disableLoopback: true to suppress receiving your own datagrams.

🧠 In-Process (Inproc) Example

Ultra-low-latency in-memory communication within the same process (no syscalls).

// Server
var server = new ReactorBuilder()
    .UseMode(TransportMode.Inproc)
    .WithChannel("demo")
    .OnReceived((p, msg) =>
    {
        Console.WriteLine($"[Server] {Encoding.UTF8.GetString(msg.Span)}");
        p.Send("Echo"u8.ToArray());
    })
    .Build();

// Client
var client = new ParticleBuilder()
    .UseMode(TransportMode.Inproc)
    .WithChannel("demo")
    .OnReceived((p, msg) =>
        Console.WriteLine($"[Client] {Encoding.UTF8.GetString(msg.Span)}"))
    .Build();

server.Start();
await client.SendAsync("Ping"u8.ToArray());

💡 Inproc mode uses a lock-free MPSC queue with hybrid event-driven polling.

🧩 IPC Example — Cross-Process Messaging

High-performance interprocess communication using shared memory and ring buffers.

// Server
var server = new ReactorBuilder()
    .UseMode(TransportMode.Ipc)
    .WithChannel("shared-mem")
    .OnReceived((p, msg) =>
    {
        Console.WriteLine($"[Server] {Encoding.UTF8.GetString(msg.Span)}");
        p.Send("Ack"u8.ToArray());
    })
    .Build();

// Client
var client = new ParticleBuilder()
    .UseMode(TransportMode.Ipc)
    .WithChannel("shared-mem")
    .OnReceived((p, msg) =>
        Console.WriteLine($"[Client] Got: {Encoding.UTF8.GetString(msg.Span)}"))
    .Build();

server.Start();
await client.SendAsync("Hi IPC!"u8.ToArray());

💡 IPC mode uses shared memory + SPSC ring buffers and supports multiple clients per reactor.

⚙️ Common Builder Options

🧪 Benchmark Results (.NET 9, x64, Release)

Tested with BenchmarkDotNet on .NET 9.0,
CPU: AMD Ryzen 9 5950X | 64 GB DDR4 | Windows 11 x64

🔍 Keywords for Developers

Tags:
.NET transport layer, zero-copy IPC, shared memory,
low latency TCP, UDP multicast, async sockets,
real-time telemetry, lock-free ring buffer, C# networking

Use Cases:
Real-time trading · Game networking · Simulation · Distributed telemetry · Robotics · HFT systems

🧾 License

MIT © 2025 — Faster.Transport Team
Optimized for real-time, low-latency, and high-throughput distributed systems.