Transactions

using System.Data;
using Microsoft.EntityFrameworkCore;

public class Invoice
{
    public int Id { get; set; }
    public int Year { get; set; }
    public int Sequence { get; set; }
    public int CustomerId { get; set; }
    public decimal Amount { get; set; }
    public string Number => $"INV-{Year}-{Sequence:D5}";
}

public class BillingDb(DbContextOptions<BillingDb> options) : DbContext(options)
{
    public DbSet<Invoice> Invoices => Set<Invoice>();

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Invoice>().Ignore(i => i.Number);
        // The last line of defence if two transactions ever pick the same number.
        modelBuilder.Entity<Invoice>().HasIndex(i => new { i.Year, i.Sequence }).IsUnique();
    }
}

public class InvoiceNumbering(BillingDb db, TimeProvider clock)
{
    // Requires UseNpgsql(..., o => o.EnableRetryOnFailure()): 40001 is retried as transient.
    public Task<Invoice> IssueAsync(int customerId, decimal amount, CancellationToken ct)
    {
        var strategy = db.Database.CreateExecutionStrategy();
        return strategy.ExecuteAsync(async () =>
        {
            db.ChangeTracker.Clear();
            await using var tx = await db.Database.BeginTransactionAsync(IsolationLevel.Serializable, ct);

            var year = clock.GetUtcNow().Year;
            var last = await db.Invoices.Where(i => i.Year == year).MaxAsync(i => (int?)i.Sequence, ct) ?? 0;

            var invoice = new Invoice { Year = year, Sequence = last + 1, CustomerId = customerId, Amount = amount };
            db.Invoices.Add(invoice);
            await db.SaveChangesAsync(ct);
            await tx.CommitAsync(ct);
            return invoice;
        });
    }
}

using Microsoft.EntityFrameworkCore;

public class PaymentRecord
{
    public Guid Id { get; set; }
    public int OrderId { get; set; }
    public decimal Amount { get; set; }
    public string ProviderReference { get; set; } = "";
}

public class PaymentsDb(DbContextOptions<PaymentsDb> options) : DbContext(options)
{
    public DbSet<PaymentRecord> Payments => Set<PaymentRecord>();
}

public class PaymentRecorder(PaymentsDb db)
{
    public async Task RecordAsync(int orderId, decimal amount, string providerReference, CancellationToken ct)
    {
        var payment = new PaymentRecord
        {
            Id = Guid.CreateVersion7(),
            OrderId = orderId,
            Amount = amount,
            ProviderReference = providerReference
        };
        db.Payments.Add(payment);

        var strategy = db.Database.CreateExecutionStrategy();
        await strategy.ExecuteInTransactionAsync(
            // acceptAllChangesOnSuccess: false keeps the entity Added in case of a retry.
            async token => await db.SaveChangesAsync(acceptAllChangesOnSuccess: false, token),
            // Runs only if the commit itself failed: did the row make it anyway?
            async token => await db.Payments.AsNoTracking().AnyAsync(p => p.Id == payment.Id, token),
            ct);

        db.ChangeTracker.AcceptAllChanges();
    }
}

using Microsoft.EntityFrameworkCore;

public record PriceRow(string Sku, decimal Price);

public class Product
{
    public int Id { get; set; }
    public string Sku { get; set; } = "";
    public decimal Price { get; set; }
}

public class CatalogDb(DbContextOptions<CatalogDb> options) : DbContext(options)
{
    public DbSet<Product> Products => Set<Product>();
}

public class PriceImport(CatalogDb db, ILogger<PriceImport> logger)
{
    public async Task<int> ImportAsync(IReadOnlyList<PriceRow[]> batches, CancellationToken ct)
    {
        var applied = 0;
        await using var tx = await db.Database.BeginTransactionAsync(ct);

        for (var i = 0; i < batches.Count; i++)
        {
            await tx.CreateSavepointAsync($"batch_{i}", ct);
            try
            {
                foreach (var row in batches[i])
                {
                    var updated = await db.Products.Where(p => p.Sku == row.Sku)
                        .ExecuteUpdateAsync(s => s.SetProperty(p => p.Price, row.Price), ct);
                    if (updated == 0) throw new InvalidOperationException($"Unknown SKU {row.Sku}");
                }
                applied += batches[i].Length;
            }
            catch (InvalidOperationException ex)
            {
                await tx.RollbackToSavepointAsync($"batch_{i}", ct);
                logger.LogWarning(ex, "Skipped price batch {Batch}", i);
            }
        }

        await tx.CommitAsync(ct);
        return applied;
    }
}