Faster.Messagebus 0.0.8

🚀 Faster.MessageBus

Faster.MessageBus is a high-performance, decentralized message bus for .NET, built on NetMQ.
It enables services to form a self-organizing, self-healing peer-to-peer mesh network — with no central broker required.

⚠️ Note: This project is currently under active development and should be considered experimental.
The API may evolve before stable release.

✨ Key Features

• ⚡ Ultra-Fast Messaging — Zero-copy serialization and minimal allocations using Span<T> and ArrayPool<T>.
• 🧩 Event & Command Dispatchers — Unified APIs for fire-and-forget events and request-reply commands.
• 🧭 Smart Routing Mechanism — Route messages locally, within a machine, across a cluster, or network-wide, even to specific applications.
• 🔁 Fluent Builder API — Configure timeouts, cancellation, and error handlers with clean, chainable syntax.
• 🔍 Automatic Discovery — Nodes automatically find each other and form a distributed mesh network.
• ❤️ Heartbeat Monitoring — Tracks node health and removes disconnected peers automatically.
• 🔒 Thread-Safe Core — Dedicated internal scheduler eliminates the need for locking in user code.
• 📦 Compact Serialization — Uses MessagePack + LZ4 for extremely fast and small payloads.

🧠 Core Architecture

Faster.MessageBus is a brokerless distributed messaging system for .NET.
Each application node acts as both publisher and subscriber, forming a mesh topology via NetMQ.

This allows:

• Event broadcasting (publish/subscribe)
• Command dispatching (request/reply)
• Scatter-gather communication
• Directed messaging to specific peers or groups

All of this happens without a central broker, giving you maximum speed, fault tolerance, and zero configuration overhead.

🧭 Intelligent Routing System

Faster.MessageBus introduces a 4-tier routing system, giving you full control over where and how messages travel.

Additionally, messages can target specific applications directly using:

.SendToAsync("app-name", command, timeout);

💬 Routing Examples

🔹 Local Command

await messageBus.CommandDispatcher.Local
    .Prepare(new CacheRefreshCommand())
    .WithTimeout(TimeSpan.FromSeconds(2))
    .SendAsync();

🔹 Machine-Scoped Broadcast

await foreach (var response in messageBus.CommandDispatcher.Machine
    .Prepare(new GetSystemStatusCommand())
    .WithTimeout(TimeSpan.FromSeconds(3))
    .StreamAsync())
{
    Console.WriteLine($"Local service reported: {response.State}");
}

🔹 Cluster-Wide Scatter-Gather

await foreach (var result in messageBus.CommandDispatcher.Cluster
    .Prepare(new SyncDatabaseCommand())
    .WithTimeout(TimeSpan.FromSeconds(5))
    .StreamResultAsync())
{
    if (result.IsSuccess)
        Console.WriteLine($"✔ Synced node: {result.Value.NodeName}");
    else
        Console.WriteLine($"⚠ Failed: {result.Error.Message}");
}

🔹 Directed Command (Targeted Application)

var response = await messageBus.CommandDispatcher.Network
    .Prepare(new GetMetricsCommand())
    .WithTimeout(TimeSpan.FromSeconds(2))
    .SendToAsyncWithResult("pc2");

Console.WriteLine($"Metrics from pc2: {response.CpuUsage}%");

🔹 Event Broadcast

await messageBus.EventDispatcher.Publish(
    new UserCreatedEvent(Guid.NewGuid(), "Alice"),
    TimeSpan.FromSeconds(5),
    CancellationToken.None
);

Handler:

public class UserCreatedEventHandler(ILogger<UserCreatedEventHandler> logger)
    : IEventHandler<UserCreatedEvent>
{
    public void Handle(UserCreatedEvent @event)
    {
        logger.LogInformation($"User created: {@event.UserName}");
    }
}

🧱 Fluent Command Builder Overview

Example:

await messageBus.CommandDispatcher.Cluster
    .Prepare(new ReplicateCacheCommand())
    .WithTimeout(TimeSpan.FromSeconds(4))
    .OnTimeout((ex, ctx) => Console.WriteLine($"Timeout on {ctx.ApplicationId}: {ex.Message}"))
    .SendAsync();

⚙️ Service Registration

services.AddEventHandlers();
services.AddCommandHandlers();

Automatically discovers and registers:

• IEventHandler<T>
• ICommandHandler<T>
• ICommandHandler<T, TResult>

Works across .NET Framework, .NET Standard, .NET 8, and .NET 9.

🔍 SEO Keywords

.NET message bus • decentralized messaging • peer-to-peer message broker •
brokerless messaging system • distributed command routing • zero-broker architecture •
message queue alternative • high-performance messaging • event-driven .NET framework •
service mesh messaging • NetMQ command bus • publish/subscribe in .NET • scatter-gather commands

🤝 Contributing

Contributions are welcome! 🎉
Please open an issue first to discuss any proposed changes or enhancements.

📜 License

Licensed under the MIT License.