SaveChangesAsync

using Microsoft.EntityFrameworkCore;

public interface IAudited
{
    DateTimeOffset CreatedAt { get; set; }
    DateTimeOffset UpdatedAt { get; set; }
}

public class Invoice : IAudited
{
    public int Id { get; set; }
    public decimal Amount { get; set; }
    public DateTimeOffset CreatedAt { get; set; }
    public DateTimeOffset UpdatedAt { get; set; }
}

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

    public override Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken cancellationToken = default)
    {
        var now = clock.GetUtcNow();
        foreach (var entry in ChangeTracker.Entries<IAudited>())
        {
            if (entry.State == EntityState.Added)
                entry.Entity.CreatedAt = now;
            if (entry.State is EntityState.Added or EntityState.Modified)
                entry.Entity.UpdatedAt = now;
        }
        return base.SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken);
    }
}

using Microsoft.EntityFrameworkCore;

public record PriceRow(string Sku, decimal Price);

public sealed class PriceImport(CatalogDb db)
{
    // 5,000 rows: 5,000 transactions and round trips; a failure at row 3,000 leaves a half-applied import.
    public async Task ImportSlow(IReadOnlyList<PriceRow> rows, CancellationToken ct)
    {
        foreach (var row in rows)
        {
            var product = await db.Products.SingleAsync(p => p.Sku == row.Sku, ct);
            product.Price = row.Price;
            await db.SaveChangesAsync(ct);
        }
    }

    // One query, one SaveChanges: one transaction, batched UPDATEs, all or nothing.
    public async Task<int> Import(IReadOnlyList<PriceRow> rows, CancellationToken ct)
    {
        var bySku = rows.ToDictionary(r => r.Sku, r => r.Price);
        var skus = bySku.Keys.ToList();
        var products = await db.Products.Where(p => skus.Contains(p.Sku)).ToListAsync(ct);
        foreach (var product in products)
            product.Price = bySku[product.Sku];
        return await db.SaveChangesAsync(ct);   // only rows whose price really changed are written
    }
}

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>();
}

using Microsoft.EntityFrameworkCore;

public sealed class PaymentRecorder(ShopDb db)
{
    public async Task Record(int orderId, string providerPaymentId, decimal amount, CancellationToken ct)
    {
        var order = await db.Orders.SingleAsync(o => o.Id == orderId, ct);
        order.Status = "Paid";
        db.Payments.Add(new Payment { OrderId = orderId, ProviderPaymentId = providerPaymentId, Amount = amount });

        var strategy = db.Database.CreateExecutionStrategy();
        await strategy.ExecuteInTransactionAsync(
            // false: if the commit fails and the strategy retries, the changes are still pending.
            operation: token => db.SaveChangesAsync(acceptAllChangesOnSuccess: false, token),
            // A commit can reach the server and lose only its acknowledgement. Before retrying,
            // check whether it really committed, so the payment is never recorded twice.
            verifySucceeded: token => db.Payments.AsNoTracking()
                .AnyAsync(p => p.ProviderPaymentId == providerPaymentId, token),
            cancellationToken: ct);

        db.ChangeTracker.AcceptAllChanges();   // only after a confirmed commit
    }
}

public class Order
{
    public int Id { get; set; }
    public string Status { get; set; } = "";
}

public class Payment
{
    public int Id { get; set; }
    public int OrderId { get; set; }
    public string ProviderPaymentId { get; set; } = "";
    public decimal Amount { get; set; }
}

public class ShopDb(DbContextOptions<ShopDb> options) : DbContext(options)
{
    public DbSet<Order> Orders => Set<Order>();
    public DbSet<Payment> Payments => Set<Payment>();

    // The last line of defence: a second row for the same provider payment cannot exist.
    protected override void OnModelCreating(ModelBuilder modelBuilder) =>
        modelBuilder.Entity<Payment>().HasIndex(p => p.ProviderPaymentId).IsUnique();
}