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

• 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.