Coder Legion - Recent posts tagged masstransit

MassTransit in ASP.NET Core: A Practical Guide to Event-Driven .NET

Mon, 29 Sep 2025 09:25:53 +0000

MassTransit in ASP.NET Core: A Practical Guide to Event-Driven .NET
Intro

Event-driven architectures help teams decouple services, scale independently, and handle failures gracefully. MassTransit is a mature, open-source library that makes message-based workflows in .NET straightforward. This guide shows a minimal but production-ready setup in ASP.NET Core with RabbitMQ.

1) Install packages

From your Web API project:

dotnet add package MassTransit
dotnet add package MassTransit.RabbitMQ

(For Azure Service Bus use MassTransit.Azure.ServiceBus.Core instead.)

2) Define a message contract

Contracts should be versionable and live in a shared project.

public interface SubmitOrder
{
    Guid OrderId { get; }
    string CustomerId { get; }
    DateTime Timestamp { get; }
}

3) Create a consumer

using MassTransit;

public sealed class SubmitOrderConsumer : IConsumer<SubmitOrder>
{
    public async Task Consume(ConsumeContext<SubmitOrder> context)
    {
        var msg = context.Message;
        // Your domain logic here (idempotent!)
        Console.WriteLine($"Received SubmitOrder {msg.OrderId} for {msg.CustomerId}");
        await Task.CompletedTask;
    }
}

4) Configure MassTransit in Program.cs (.NET 9 minimal hosting)

RabbitMQ example with retries and health checks.

using MassTransit;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddMassTransit(cfg =>
{
    cfg.SetKebabCaseEndpointNameFormatter();

    cfg.AddConsumer<SubmitOrderConsumer>(c =>
    {
        // optional: configure consumer-level retry, etc.
    });

    cfg.UsingRabbitMq((context, bus) =>
    {
        bus.Host("rabbitmq", h =>
        {
            h.Username("guest");
            h.Password("guest");
        });

        bus.ReceiveEndpoint("submit-order-queue", e =>
        {
            e.ConfigureConsumeTopology = false; 
            e.ConfigureConsumer<SubmitOrderConsumer>(context);

            e.UseMessageRetry(r => r.Interval(3, TimeSpan.FromSeconds(5)));
            e.PrefetchCount = 16;
            e.ConcurrentMessageLimit = 8;
        });
    });
});

builder.Services.AddHealthChecks();

var app = builder.Build();
app.MapHealthChecks("/health");
app.MapGet("/", () => "OK");
app.Run();

Docker tip

If you run RabbitMQ locally via Docker:

docker run -d --hostname rabbit \
  -p 5672:5672 -p 15672:15672 \
  --name rabbitmq rabbitmq:3-management

UI is at http://localhost:15672 (guest/guest).

5) Publish a message (from a Controller or Service)

Inject IPublishEndpoint for pub/sub or ISendEndpointProvider for point-to-point.

using MassTransit;

public sealed class OrderAppService
{
    private readonly IPublishEndpoint _publish;
    public OrderAppService(IPublishEndpoint publish) => _publish = publish;

    public Task SubmitAsync(Guid orderId, string customerId)
        => _publish.Publish<SubmitOrder>(new
        {
            OrderId = orderId,
            CustomerId = customerId,
            Timestamp = DateTime.UtcNow
        });
}

Or via an endpoint (send to a specific queue):

public sealed class OrderSender
{
    private readonly ISendEndpointProvider _send;
    public OrderSender(ISendEndpointProvider send) => _send = send;

    public async Task SendAsync(Guid orderId, string customerId)
    {
        var endpoint = await _send.GetSendEndpoint(new Uri("queue:submit-order-queue"));
        await endpoint.Send<SubmitOrder>(new { OrderId = orderId, CustomerId = customerId, Timestamp = DateTime.UtcNow });
    }
}

6) Error handling, retries, and observability

Retries: use UseMessageRetry on endpoints or the bus. Prefer bounded retries with intervals or exponential backoff.

Poison messages: failed messages after retries land in _error queues automatically.

Health checks: expose /health and rely on container orchestration to restart unhealthy pods.

Idempotency: make consumers safe to reprocess (e.g., check a processed table or use dedup keys).

7) (Optional) Outbox & transactions

If you publish events within a DB transaction, consider an outbox pattern (MassTransit integrates with EFCore Outbox) to avoid dual-write issues and ensure at-least-once delivery without duplicates.

8) Azure Service Bus variant (quick sketch)

Swap the transport:

builder.Services.AddMassTransit(cfg =>
{
    cfg.AddConsumer<SubmitOrderConsumer>();

    cfg.UsingAzureServiceBus((context, bus) =>
    {
        bus.Host(builder.Configuration["ASB_CONNECTION"]!);

        bus.SubscriptionEndpoint<SubmitOrder>("submit-order-sub", e =>
        {
            e.ConfigureConsumer<SubmitOrderConsumer>(context);
            e.MaxConcurrentCalls = 8;
        });
    });
});

Conclusion

MassTransit keeps the happy path simple while giving you the tools for serious systems: retries, sagas, scheduling, observability, and transport flexibility. Start minimal, add policies as you learn your failure modes, and keep consumers idempotent.

Building a Pub/Sub System in .NET: MassTransit, Reactive Extensions, and BlockingCollection

Tue, 26 Aug 2025 13:57:29 +0000

Modern applications often need to broadcast events across multiple services.
Think of an order being placed in an e-commerce system. The order service publishes an event, and multiple subscribers react independently:

the billing service charges the customer,
the email service sends a receipt,
the analytics service tracks the order.

This is the essence of the Publish/Subscribe (Pub/Sub) pattern.

In this post we’ll explore what it is, why it matters, and three implementations in .NET:

MassTransit with RabbitMQ (for distributed systems)

Reactive Extensions (Rx) (for in-memory event streams)

BlockingCollection (for producer/consumer pipelines)

What is the Pub/Sub Pattern

The Pub/Sub pattern decouples senders from receivers.
The Publisher creates a message (e.g., OrderSubmitted) and sends it
to a broker or channel.
The Broker delivers that message to all interested Subscribers.

Each Subscriber receives a copy of the message and processes it independently.

Benefits

Decoupling — publishers do not know subscribers
Scalability — multiple subscribers can process in parallel
Flexibility — add or remove subscribers without changing the
publisher

Why it matters

This pattern has been around for decades in middleware like IBM MQ, JMS, RabbitMQ, and Kafka.
It is fundamental in:

Event-driven microservices

Real-time systems (chat apps, trading platforms)
Notification and alerting systems
Data pipelines and analytics

IoT device communication

At its core, Pub/Sub enables loose coupling and asynchronous communication.

⚙️ Hosted Services in ASP.NET Core

A hosted service is a background task that runs with your app host.
In .NET you typically inherit from BackgroundService and implement ExecuteAsync.

public class SampleWorker : BackgroundService
{
    private readonly ILogger<SampleWorker> _log;
    public SampleWorker(ILogger<SampleWorker> log) => _log = log;

    protected override async Task ExecuteAsync(CancellationToken ct)
    {
        _log.LogInformation("Worker started");
        while (!ct.IsCancellationRequested)
        {
            // do work here
            await Task.Delay(TimeSpan.FromSeconds(5), ct);
        }
        _log.LogInformation("Worker stopping");
    }
}

// Register in Program.cs
builder.Services.AddHostedService<SampleWorker>();

In the MassTransit demo below, a PublisherService is implemented as a hosted service to periodically publish messages.

1️⃣ Pub/Sub with MassTransit and RabbitMQ

appsettings.json
{
  "RabbitMq": { "Host": "localhost", "Username": "guest", "Password": "guest" },
  "PublishIntervalSeconds": 5
}

OrderSubmitted.cs

namespace MassTransitDemo;

public record OrderSubmitted(Guid OrderId, string CustomerEmail, decimal Total);

OrderSubmittedConsumer.cs

using MassTransit;
using Microsoft.Extensions.Logging;

namespace MassTransitDemo;

public class OrderSubmittedConsumer(ILogger<OrderSubmittedConsumer> logger) : IConsumer<OrderSubmitted>
{
    public Task Consume(ConsumeContext<OrderSubmitted> context)
    {
        var m = context.Message;
        logger.LogInformation("Consumed OrderSubmitted, OrderId {OrderId}, Email {Email}, Total {Total}",
            m.OrderId, m.CustomerEmail, m.Total);
        return Task.CompletedTask;
    }
}

PublisherService.cs

using MassTransit;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;

namespace MassTransitDemo;

public class PublisherOptions
{
    public int PublishIntervalSeconds { get; set; } = 5;
}

public class PublisherService(
    ILogger<PublisherService> logger,
    IPublishEndpoint publishEndpoint,
    IOptions<PublisherOptions> options) : BackgroundService
{
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        var delay = TimeSpan.FromSeconds(options.Value.PublishIntervalSeconds);
        logger.LogInformation("Publisher started, interval {Seconds}s", options.Value.PublishIntervalSeconds);

        while (!stoppingToken.IsCancellationRequested)
        {
            var msg = new OrderSubmitted(Guid.NewGuid(), "*Emails are not allowed*", Random.Shared.Next(50, 300));
            await publishEndpoint.Publish(msg, stoppingToken);
            logger.LogInformation("Published OrderSubmitted, OrderId {OrderId}", msg.OrderId);
            await Task.Delay(delay, stoppingToken);
        }

        logger.LogInformation("Publisher stopping");
    }
}

Program.cs

    using MassTransit;
    using MassTransitDemo;
    using Microsoft.Extensions.Configuration;
    using Microsoft.Extensions.Hosting;
    using Microsoft.Extensions.Logging;
    
    var builder = Host.CreateApplicationBuilder(args);
    
    builder.Configuration.AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
    builder.Services.Configure<PublisherOptions>(builder.Configuration);
    
    builder.Services.AddMassTransit(mt =>
    {
        mt.AddConsumer<OrderSubmittedConsumer>();
    
        mt.UsingRabbitMq((ctx, cfg) =>
        {
            var section = builder.Configuration.GetSection("RabbitMq");
            cfg.Host(section["Host"], h =>
            {
                h.Username(section["Username"]);
                h.Password(section["Password"]);
            });
    
            cfg.ReceiveEndpoint("masstransitdemo-order-submitted", e =>
            {
                e.ConfigureConsumer<OrderSubmittedConsumer>(ctx);
            });
    
            cfg.UseMessageRetry(r => r.Interval(3, TimeSpan.FromSeconds(5)));
            cfg.UseInMemoryOutbox();
        });
    });
    
    builder.Services.AddHostedService<PublisherService>();
    
    builder.Logging.ClearProviders();
    builder.Logging.AddSimpleConsole(o =>
    {
        o.SingleLine = true;
        o.TimestampFormat = "HH:mm:ss ";
    });
    
    await builder.Build().RunAsync();

Run RabbitMQ

docker run -it --rm -p 5672:5672 -p 15672:15672 rabbitmq:3-management
# UI at http://localhost:15672  user guest  pass guest

MassTransit is a distributed application framework for message brokers like RabbitMQ and Azure Service Bus. It takes care of serialization, consumer lifecycle, retries, and endpoint setup.

2️⃣ Pub/Sub with Reactive Extensions (Rx)

Reactive Extensions (Rx)
is a library for composing asynchronous and event based programs with observable sequences.

Uses IObservable (event source) and IObserver (subscriber)

Provides LINQ-style operators (Where, Select, Buffer) for event streams

Perfect for in-memory event pipelines and UI scenarios

⚠️ Limitation: Rx is in-memory only. Events vanish when the app stops.

Program.cs

using System;
using System.Reactive.Linq;
using System.Reactive.Subjects;

public record OrderSubmitted(Guid OrderId, string CustomerEmail, decimal Total);

class Program
{
    static void Main()
    {
        var bus = new Subject<OrderSubmitted>();

        // Subscriber A
        var subA = bus.Subscribe(order =>
            Console.WriteLine($"[Email] Send receipt to {order.CustomerEmail}"));

        // Subscriber B with filter and transform
        var subB = bus
            .Where(o => o.Total >= 100)
            .Select(o => new { o.OrderId, Vat = o.Total * 0.24m })
            .Subscribe(x =>
                Console.WriteLine($"[Analytics] Order {x.OrderId}, VAT {x.Vat:F2}"));

        // Publish a few messages
        bus.OnNext(new OrderSubmitted(Guid.NewGuid(), "*Emails are not allowed*", 79.90m));
        bus.OnNext(new OrderSubmitted(Guid.NewGuid(), "*Emails are not allowed*", 149.00m));
        bus.OnNext(new OrderSubmitted(Guid.NewGuid(), "*Emails are not allowed*", 220.00m));

        bus.OnCompleted();
        subA.Dispose();
        subB.Dispose();
    }
}

3️⃣ Pub/Sub with BlockingCollection

BlockingCollection is a thread safe producer and consumer collection in .NET.

Supports blocking (consumers wait until data is available)

Supports bounding (limit capacity to avoid flooding)

Useful for background workers, pipelines, or batch processors

Program.cs

using System.Collections.Concurrent;

public record OrderSubmitted(Guid OrderId, string CustomerEmail, decimal Total);

class Program
{
    static async Task Main()
    {
        using var queue = new BlockingCollection<OrderSubmitted>(boundedCapacity: 100);

        // Subscriber A
        var emailTask = Task.Run(() =>
        {
            foreach (var order in queue.GetConsumingEnumerable())
                Console.WriteLine($"[Email] Send receipt to {order.CustomerEmail}");
        });

        // Subscriber B
        var analyticsTask = Task.Run(() =>
        {
            foreach (var order in queue.GetConsumingEnumerable())
                Console.WriteLine($"[Analytics] Track order {order.OrderId}, total {order.Total}");
        });

        // Publisher
        foreach (var price in new[] { 49.50m, 129.00m, 250.00m, 15.00m })
        {
            queue.Add(new OrderSubmitted(Guid.NewGuid(), $"user{price}@example.com", price));
        }

        queue.CompleteAdding();
        await Task.WhenAll(emailTask, analyticsTask);
    }
}

⚠️ Limitation: Only works inside a single process. No distribution.

References

MassTransit Documentation

MassTransit GitHub

RabbitMQ Tutorials

Microsoft Docs: Worker Services

Microsoft Docs: Publisher-Subscriber Pattern

System.Reactive GitHub

BlockingCollection Overview

✅ With these three approaches, you now have the full spectrum of Pub/Sub in .NET:

Lightweight in-memory streams with Rx and BlockingCollection

Robust distributed messaging with MassTransit and RabbitMQ

The Pub/Sub pattern has lasted decades because it makes systems more modular, more scalable, and more resilient to change.

Building an Order Processing Saga with MassTransit

Tue, 12 Aug 2025 09:22:53 +0000

MassTransit has been around since 2007 and has matured into one of the most stable and feature-rich open-source .NET messaging frameworks.

It acts like a factory for message brokers, meaning you can switch between providers such as RabbitMQ, Azure Service Bus, ActiveMQ, Amazon SQS, and others with minimal configuration changes.

This makes it ideal for enterprise-grade distributed systems where you want flexibility without vendor lock-in.

Why MassTransit?

Stability: Over a decade of continuous development and production use.

Multi-Broker Support: Easily swap between Azure Service Bus, RabbitMQ, Amazon SQS, etc., without rewriting business logic.

Developer Friendly: Built for .NET developers with excellent documentation and integration with DI, EF Core, and ASP.NET Core.

Advanced Features:

Outbox pattern
Request/Response messaging
Retry and circuit-breaker policies
Sagas and State Machines
Message scheduling

One of the Coolest Features: The State Machine

A State Machine allows you to model complex workflows where messages arrive in any order, but your application processes them in a controlled, state-aware sequence.

For example, in this Order Processing Saga:

An order is submitted.
The saga waits for stock confirmation.
If stock is reserved, the saga waits for payment authorization.
Once payment is authorized, the order is marked as completed.
If any step fails, the saga can transition to a failed state and trigger compensating actions.

This approach eliminates spaghetti code for multi-step processes and makes workflows easy to visualize and maintain.

Technology Stack Used in This Project
.NET 9

MassTransit (with Saga State Machine)
RabbitMQ (message broker)
PostgreSQL (saga persistence)
Entity Framework Core (database access)
Docker (local RabbitMQ/PostgreSQL setup)

Source Code
Full working implementation available here:
GitHub – OutboxSagaDemo

References

MassTransit Documentation – https://masstransit.io/

MassTransit GitHub Repository – https://github.com/MassTransit/MassTransit

MassTransit Saga State Machine Guide – https://masstransit.io/documentation/patterns/saga

RabbitMQ Documentation – https://www.rabbitmq.com/documentation.html

PostgreSQL Documentation – https://www.postgresql.org/docs/

Entity Framework Core Docs – https://learn.microsoft.com/en-us/ef/core/