Implement order placement so the order and durable integration-event record commit atomically.

Create a new order and a corresponding OutboxMessage in the same AppDbContext. One SaveChangesAsync should persist both atomically. A separate worker will publish pending outbox rows; the request must not call the message broker directly.

If the outbox insert fails, the order insert rolls back. If the database commit succeeds but the process stops immediately afterward, the pending outbox row remains for the worker.

• Use one DbContext and one SaveChanges call.
• Serialize a stable event contract, not the tracked entity graph.
• Assign a unique event id.
• Do not publish externally before or inside the database commit.

I create the aggregate and a small integration-event payload, add both rows to the same context, and save once. EF wraps one SaveChanges operation in a transaction when multiple statements are required. The request returns after durable state exists; a worker owns publication, retries, and marking the outbox row processed.

public static async Task<PlaceOrderResult> PlaceOrderAsync(
    AppDbContext db,
    PlaceOrder command,
    CancellationToken cancellationToken)
{
    var order = Order.Place(
        command.CustomerId,
        command.Lines,
        command.IdempotencyKey);

    var integrationEvent = new OrderPlacedV1(
        order.Id,
        order.CustomerId,
        order.Total,
        order.PlacedAtUtc);

    var outbox = OutboxMessage.Create(
        Guid.NewGuid(),
        "orders.placed.v1",
        JsonSerializer.Serialize(integrationEvent),
        order.PlacedAtUtc);

    db.Orders.Add(order);
    db.OutboxMessages.Add(outbox);

    await db.SaveChangesAsync(cancellationToken);
    return new PlaceOrderResult(order.Id);
}

One SaveChanges call creates a local database transaction around order, line, and outbox inserts. A unique idempotency key protects repeated requests, while a unique outbox id and worker-side publish strategy handle delivery retries. Exactly-once external delivery is not assumed.

• The request is retried after a timeout with the same idempotency key.
• Serialization fails before SaveChanges.
• The outbox insert violates a constraint.
• The worker publishes successfully but crashes before marking processed.

• Force the outbox insert to fail and verify no order remains.
• Repeat the command with the same idempotency key.
• Test duplicate publication handling in the consumer.
• Verify no broker call occurs in the request transaction.

• Saving the order and outbox in separate commits.
• Publishing to the broker before the database commit.
• Serializing an entire EF entity graph as the event contract.
• Claiming the outbox guarantees exactly-once processing.