Messaging

// Program.csbuilder.Host.UseWolverine(opts =>{    // Auto-discover handlers from this assembly    opts.Discovery.IncludeAssembly(typeof(Program).Assembly);
    // RabbitMQ transport    opts.UseRabbitMq(rabbit =>    {        rabbit.HostName = "localhost";        // Or from configuration:        // rabbit.HostName = builder.Configuration["RabbitMq:Host"]!;    })    .AutoProvision()   // Create queues/exchanges automatically    .AutoPurgeOnStartup(); // Dev only — clear queues on startup
    // Enable transactional outbox with EF Core    opts.Services.AddDbContextWithWolverineIntegration<AppDbContext>(x =>        x.UseNpgsql(builder.Configuration.GetConnectionString("Default")));
    opts.Policies.AutoApplyTransactions(); // Wrap handlers in DB transactions});

// Message contract (in shared Contracts project)public record OrderCreated(Guid OrderId, string CustomerId, decimal Total, DateTimeOffset CreatedAt);
// Style 1: Cascading messages — return the event from the handler// Wolverine automatically publishes returned messages after the handler completes.public static class CreateOrder{    public record Command(string CustomerId, List<OrderItem> Items);    public record Response(Guid OrderId, decimal Total);
    public static async Task<(Response, OrderCreated)> HandleAsync(        Command command, AppDbContext db, TimeProvider clock, CancellationToken ct)    {        var order = Order.Create(command.CustomerId, command.Items, clock.GetUtcNow());        db.Orders.Add(order);        await db.SaveChangesAsync(ct);
        var response = new Response(order.Id, order.Total);        var @event = new OrderCreated(order.Id, order.CustomerId, order.Total, order.CreatedAt);
        return (response, @event); // Both are published automatically    }}

// Style 2: Explicit publishing via IMessageBuspublic static class CreateOrder{    public record Command(string CustomerId, List<OrderItem> Items);    public record Response(Guid OrderId, decimal Total);
    public static async Task<Response> HandleAsync(        Command command, AppDbContext db, IMessageBus bus, TimeProvider clock, CancellationToken ct)    {        var order = Order.Create(command.CustomerId, command.Items, clock.GetUtcNow());        db.Orders.Add(order);        await db.SaveChangesAsync(ct);
        await bus.PublishAsync(new OrderCreated(            order.Id, order.CustomerId, order.Total, order.CreatedAt));
        return new Response(order.Id, order.Total);    }}

// Notifications module — handles OrderCreated from Orders modulepublic static class OrderCreatedHandler{    public static async Task HandleAsync(        OrderCreated message, NotificationsDbContext db, ILogger logger, CancellationToken ct)    {        logger.LogInformation("Processing OrderCreated: {OrderId}", message.OrderId);
        var notification = new OrderNotification(message.OrderId, message.CustomerId);        db.Notifications.Add(notification);        await db.SaveChangesAsync(ct);    }}

// 1. Register DbContext with Wolverine integrationbuilder.Host.UseWolverine(opts =>{    opts.Services.AddDbContextWithWolverineIntegration<AppDbContext>(x =>        x.UseNpgsql(builder.Configuration.GetConnectionString("Default")));
    opts.Policies.AutoApplyTransactions();});
// 2. DbContext — add Wolverine outbox tablespublic class AppDbContext(DbContextOptions<AppDbContext> options) : DbContext(options){    public DbSet<Order> Orders => Set<Order>();
    protected override void OnModelCreating(ModelBuilder modelBuilder)    {        // Wolverine inbox/outbox tables — required for transactional messaging        modelBuilder.AddIncomingWolverineMessageTable();        modelBuilder.AddOutgoingWolverineMessageTable();    }}

public record OrderSagaState(Guid Id){    public string? CustomerId { get; set; }    public bool PaymentReceived { get; set; }}
public class OrderSaga : Saga<OrderSagaState>{    public Guid Id { get; set; }
    // Start the saga when an OrderCreated event arrives    public static (OrderSagaState, ProcessPayment) Start(OrderCreated message)    {        var state = new OrderSagaState(message.OrderId)        {            CustomerId = message.CustomerId        };
        var command = new ProcessPayment(message.OrderId, message.Total);        return (state, command); // State is persisted, command is sent    }
    // Handle payment result    public CompleteOrder Handle(PaymentCompleted message)    {        PaymentReceived = true;        MarkCompleted(); // Ends the saga        return new CompleteOrder(Id);    }
    // Compensating action on failure    public CancelOrder Handle(PaymentFailed message)    {        MarkCompleted();        return new CancelOrder(Id);    }}

// Setupbuilder.Services.AddMassTransit(x =>{    x.SetKebabCaseEndpointNameFormatter();    x.AddConsumers(typeof(Program).Assembly);    x.UsingRabbitMq((context, cfg) =>    {        cfg.Host(builder.Configuration.GetConnectionString("RabbitMq"));        cfg.ConfigureEndpoints(context);    });});
// Publishingawait publishEndpoint.Publish(new OrderCreated(...), ct);
// Consuming — requires IConsumer<T> interfacepublic class OrderCreatedConsumer(AppDbContext db) : IConsumer<OrderCreated>{    public async Task Consume(ConsumeContext<OrderCreated> context)    {        var message = context.Message;        // Handle event...    }}
// Outboxx.AddEntityFrameworkOutbox<AppDbContext>(o =>{    o.UsePostgres();    o.UseBusOutbox();});
// Saga — uses MassTransitStateMachine<TState>public class OrderSaga : MassTransitStateMachine<OrderSagaState> { /* ... */ }

// BAD — if SaveChanges succeeds but Publish fails, data is inconsistentawait db.SaveChangesAsync(ct);await bus.PublishAsync(new OrderCreated(...));
// GOOD — use transactional outbox (messages are in the same transaction)// Configure AddDbContextWithWolverineIntegration() + AutoApplyTransactions()// Wolverine handles this automatically

// BAD — behavior in a messagepublic record OrderCreated(Guid OrderId){    public decimal CalculateShipping() => /* logic */; // DON'T}
// GOOD — messages are pure datapublic record OrderCreated(Guid OrderId, string CustomerId, decimal Total, DateTimeOffset CreatedAt);

// BAD — no guarantee of delivery_ = Task.Run(() => bus.PublishAsync(new OrderCreated(...)));
// GOOD — await the publish (with outbox, this is transactional)await bus.PublishAsync(new OrderCreated(...));