SimpleMessageBroker.Client 0.0.5

SimpleMessageBroker.Client

C# Client SDK for SimpleMessageBroker — a lightweight single-node message queue middleware.

Features

• JSON over HTTP — RESTful API communication, easy to integrate and debug
• byte[] Payload — serialization-agnostic; bring your own serializer
• DI Integration — one-liner AddMessageQueueClient() registration with IHttpClientFactory connection pooling
• Exponential Backoff Retry — automatic retry on HTTP 5xx, network timeout, and connection failures (no retry on 4xx)
• Batch Operations — produce and acknowledge messages in batches
• Typed Message Handler — IMessageHandler<T> for type-safe message consumption
• Multi-TFM Support — targets net8.0 and net10.0

Supported Frameworks

Dependencies

Installation

dotnet add package SimpleMessageBroker.Client

Quick Start

1. Register the client

using SimpleMessageBroker.Client.Extensions;

builder.Services.AddMessageQueueClient(options =>
{
    options.BaseAddress = "http://localhost:5000";
    // options.ApiKey = "your-api-key";       // optional
    // options.DefaultTimeout = TimeSpan.FromSeconds(30);
    // options.MaxRetries = 3;
    // options.MaxConnectionsPerServer = 50;
});

2. Produce messages

var client = serviceProvider.GetRequiredService<IMessageQueueClient>();

var payload = JsonSerializer.SerializeToUtf8Bytes(new { OrderId = "123", Amount = 99.99 });

var result = await client.ProduceAsync(
    topic: "orders",
    payload: payload,
    key: "user-123",
    contentType: "application/json",
    headers: new Dictionary<string, string>
    {
        ["source"] = "order-service"
    });

Console.WriteLine($"Message ID: {result.MessageId}, Partition: {result.Partition}");

3. Consume messages

var result = await client.ConsumeAsync(
    topic: "orders",
    consumerGroup: "payment-service",
    consumerId: "payment-instance-1",
    batchSize: 10,
    timeoutSeconds: 30);

foreach (var msg in result.Messages)
{
    // Process the message...
    var order = JsonSerializer.Deserialize<MyOrder>(msg.Payload);

    // Acknowledge after successful processing
    await client.AcknowledgeAsync(msg.Id, "payment-service", "payment-instance-1");
}

4. Batch produce

var messages = new List<ProduceMessage>
{
    new()
    {
        Topic = "orders",
        Payload = JsonSerializer.SerializeToUtf8Bytes(new { OrderId = "001" }),
        Key = "user-001",
        ContentType = "application/json"
    },
    new()
    {
        Topic = "orders",
        Payload = JsonSerializer.SerializeToUtf8Bytes(new { OrderId = "002" }),
        Key = "user-002",
        ContentType = "application/json"
    }
};

var results = await client.ProduceBatchAsync(messages);

API Reference

IMessageQueueClient

IMessageHandler<T>

Generic typed message handler for type-safe consumption:

public class OrderHandler : IMessageHandler<OrderPayload>
{
    public Task HandleAsync(OrderPayload message, MessageContext context, CancellationToken ct = default)
    {
        Console.WriteLine($"Processing order {message.OrderId} from partition {context.Partition}");
        return Task.CompletedTask;
    }
}

IPayloadSerializer

Serialization interface — implement your own (SDK does NOT include any built-in serializer):

public interface IPayloadSerializer
{
    byte[] Serialize<T>(T obj);
    T Deserialize<T>(byte[] data);
}

Configuration

MessageQueueClientOptions:

Retry Policy

Built-in exponential backoff retry with the following behavior:

Backoff sequence (default): 100ms → 200ms → 400ms (max 3 retries).

License

MIT