Транзакции в EF Core: SaveChanges, BeginTransaction, Ambient transactions?

db.Orders.Add(order);
db.Stock.Update(stockItem);
db.AuditLog.Add(new AuditRecord("order.created", order.Id));
await db.SaveChangesAsync();
// BEGIN; INSERT orders...; UPDATE stock...; INSERT audit_log...; COMMIT;
// Ошибка любой команды → ROLLBACK всего

await using var tx = await db.Database.BeginTransactionAsync(IsolationLevel.RepeatableRead, ct);
try
{
    var order = await db.Orders.SingleAsync(o => o.Id == id, ct);
    order.MarkPaid();
    await db.SaveChangesAsync(ct);                                   // 1-й SaveChanges — внутри tx

    await db.Products
        .Where(p => order.Items.Select(i => i.ProductId).Contains(p.Id))
        .ExecuteUpdateAsync(s => s.SetProperty(p => p.SoldCount, p => p.SoldCount + 1), ct);  // bulk — внутри tx

    db.Invoices.Add(Invoice.For(order));
    await db.SaveChangesAsync(ct);                                   // 2-й SaveChanges — внутри tx

    await tx.CommitAsync(ct);
}
catch
{
    await tx.RollbackAsync(ct);    // необязательно: Dispose без Commit откатит сам
    throw;
}

await tx.CreateSavepointAsync("before-bonus", ct);
try { await ApplyBonusAsync(ct); }
catch (BonusException) { await tx.RollbackToSavepointAsync("before-bonus", ct); }

builder.Services.AddDbContext<ShopDbContext>(o => o.UseNpgsql(conn, npg => npg.EnableRetryOnFailure(maxRetryCount: 5)));

var strategy = db.Database.CreateExecutionStrategy();
await strategy.ExecuteAsync(async () =>
{
    db.ChangeTracker.Clear();                                        // повтор начинается с чистого состояния
    await using var tx = await db.Database.BeginTransactionAsync(ct);
    // ... вся логика транзакции, включая загрузку данных
    await db.SaveChangesAsync(ct);
    await tx.CommitAsync(ct);
});

using var scope = new TransactionScope(
    TransactionScopeOption.Required,
    new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted, Timeout = TimeSpan.FromSeconds(30) },
    TransactionScopeAsyncFlowOption.Enabled);          // обязательно для async/await

await ordersDb.SaveChangesAsync();                     // соединение автоматически «вступает» в ambient-транзакцию
await using (var conn = new NpgsqlConnection(sameDbConn))
{
    await conn.OpenAsync();
    await conn.ExecuteAsync("INSERT INTO legacy_log ...");   // Dapper — в той же транзакции
}

scope.Complete();                                      // без Complete → откат при Dispose

await using var conn = new NpgsqlConnection(connStr);
await conn.OpenAsync(ct);
await using var tx = await conn.BeginTransactionAsync(ct);

var ordersOptions = new DbContextOptionsBuilder<OrdersContext>().UseNpgsql(conn).Options;
await using var orders = new OrdersContext(ordersOptions);
await orders.Database.UseTransactionAsync(tx, ct);        // использовать существующую транзакцию

await using var billing = new BillingContext(new DbContextOptionsBuilder<BillingContext>().UseNpgsql(conn).Options);
await billing.Database.UseTransactionAsync(tx, ct);

// ... изменения в обоих контекстах
await orders.SaveChangesAsync(ct);
await billing.SaveChangesAsync(ct);
await tx.CommitAsync(ct);