Mất cập nhật tồn kho và upsert

#:package Microsoft.EntityFrameworkCore.SqlServer@10.0.12
#:property PublishAot=false
// Hai khách cùng mua 3 sản phẩm 42 khi tồn còn 5: bốn cách viết bằng EF Core. Rồi hai đơn đầu ngày cùng upsert doanh thu.
// Chạy: dotnet run TonKho.cs   (BANHANG_DB: chuỗi kết nối; cần cột dbo.SanPham.PhienBan, bảng dbo.DoanhThuNgay và thủ tục dbo.usp_DoanhThuNgay_Cong)
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using Microsoft.EntityFrameworkCore;

string cs = Environment.GetEnvironmentVariable("BANHANG_DB")
    ?? @"Server=(localdb)\MSSQLLocalDB;Database=BanHang_Thu;Integrated Security=true;TrustServerCertificate=true";
System.Globalization.CultureInfo.CurrentCulture = new("vi-VN");

// 1. Đọc entity, trừ trong C#, SaveChanges. Không có concurrency token.
await DatTon(5);
var gap = new Gap(2);
var kq = await Task.WhenAll(Enumerable.Range(0, 2).Select(_ => Task.Run(async () =>
{
    await using var db = new KhoDb(cs);
    var sp = await db.SanPham.SingleAsync(p => p.SanPhamId == 42);
    await gap.DenAsync();                       // cả hai đã đọc 5
    if (sp.TonKho < 3) return "hết hàng";
    sp.TonKho -= 3;
    await db.SaveChangesAsync();
    return "bán 3";
})));
Console.WriteLine($"1. SaveChanges, không token:      {string.Join(", ", kq)}; tồn còn {await DocTon()}");

// 2. Cùng code, entity có [Timestamp] PhienBan.
await DatTon(5);
gap = new Gap(2);
kq = await Task.WhenAll(Enumerable.Range(0, 2).Select(_ => Task.Run(async () =>
{
    await using var db = new KhoDbToken(cs);
    var sp = await db.SanPham.SingleAsync(p => p.SanPhamId == 42);
    await gap.DenAsync();
    if (sp.TonKho < 3) return "hết hàng";
    sp.TonKho -= 3;
    try { await db.SaveChangesAsync(); return "bán 3"; }
    catch (DbUpdateConcurrencyException) { return "DbUpdateConcurrencyException"; }
})));
Console.WriteLine($"2. SaveChanges, có [Timestamp]:   {string.Join(", ", kq)}; tồn còn {await DocTon()}");

// 3. Một câu UPDATE có điều kiện: ExecuteUpdateAsync.
await DatTon(5);
gap = new Gap(2);
kq = await Task.WhenAll(Enumerable.Range(0, 2).Select(_ => Task.Run(async () =>
{
    await using var db = new KhoDb(cs);
    await gap.DenAsync();
    int soDong = await db.SanPham
        .Where(p => p.SanPhamId == 42 && p.TonKho >= 3)
        .ExecuteUpdateAsync(s => s.SetProperty(p => p.TonKho, p => p.TonKho - 3));
    return soDong == 1 ? "bán 3" : "hết hàng";
})));
Console.WriteLine($"3. ExecuteUpdateAsync có điều kiện: {string.Join(", ", kq)}; tồn còn {await DocTon()}");

// 4. Đọc với UPDLOCK qua FromSql, ghi trong cùng giao dịch. B bắt đầu sau A 100 ms.
await DatTon(0); await MuaUpdlock(0);           // làm nóng: biên dịch truy vấn, mở pool
await DatTon(5);
kq = await Task.WhenAll(MuaUpdlock(0), MuaUpdlock(100));
Console.WriteLine($"4. FromSql với UPDLOCK:           {string.Join(" | ", kq)}; tồn còn {await DocTon()}");

// 5. Upsert kiểu đọc rồi chèn: FindAsync, Add nếu chưa có, SaveChanges.
var ngay = new DateTime(2026, 10, 3);
await XoaDoanhThu();
gap = new Gap(2);
kq = await Task.WhenAll(Enumerable.Range(0, 2).Select(_ => Task.Run(async () =>
{
    await using var db = new KhoDb(cs);
    var dong = await db.DoanhThuNgay.FindAsync(ngay, 42);
    await gap.DenAsync();                       // cả hai đều thấy chưa có dòng
    if (dong is null) db.DoanhThuNgay.Add(new DoanhThuNgay { Ngay = ngay, SanPhamId = 42, SoLuong = 2, DoanhThu = 500000m });
    else { dong.SoLuong += 2; dong.DoanhThu += 500000m; }
    try { await db.SaveChangesAsync(); return "ghi được"; }
    catch (DbUpdateException ex) when (ex.InnerException is Microsoft.Data.SqlClient.SqlException { Number: 2627 }) { return "lỗi 2627"; }
})));
Console.WriteLine($"5. FindAsync rồi Add:             {string.Join(", ", kq)}; {await DocDoanhThu()}");

// 6. Gọi thủ tục UPDLOCK, HOLDLOCK.
await XoaDoanhThu();
gap = new Gap(2);
await Task.WhenAll(Enumerable.Range(0, 2).Select(_ => Task.Run(async () =>
{
    await using var db = new KhoDb(cs);
    await gap.DenAsync();
    await db.Database.ExecuteSqlAsync($"EXEC dbo.usp_DoanhThuNgay_Cong @Ngay = {ngay}, @SanPhamId = 42, @SoLuong = 2, @DoanhThu = 500000.00");
})));
Console.WriteLine($"6. usp_DoanhThuNgay_Cong:         cả hai ghi được; {await DocDoanhThu()}");

async Task XoaDoanhThu()
{
    await using var db = new KhoDb(cs);
    await db.Database.ExecuteSqlAsync($"DELETE dbo.DoanhThuNgay WHERE Ngay = {ngay}");
}

async Task<string> DocDoanhThu()
{
    await using var db = new KhoDb(cs);
    var d = await db.DoanhThuNgay.AsNoTracking().SingleAsync(x => x.Ngay == ngay && x.SanPhamId == 42);
    return $"dòng (2026-10-03, 42) = ({d.SoLuong}, {d.DoanhThu:N0})";
}

async Task<string> MuaUpdlock(int treMs)
{
    await Task.Delay(treMs);
    await using var db = new KhoDb(cs);
    await using var tx = await db.Database.BeginTransactionAsync();
    var dongHo = Stopwatch.StartNew();
    var sp = await db.SanPham
        .FromSql($"SELECT * FROM dbo.SanPham WITH (UPDLOCK, ROWLOCK) WHERE SanPhamId = {42}")
        .SingleAsync();
    long choMs = dongHo.ElapsedMilliseconds;
    if (sp.TonKho < 3) return $"đọc {sp.TonKho} sau {choMs} ms, hết hàng";
    await Task.Delay(300);                      // logic nhiều bước giữa đọc và ghi
    sp.TonKho -= 3;
    await db.SaveChangesAsync();
    await tx.CommitAsync();
    return $"đọc {sp.TonKho + 3} sau {choMs} ms, bán 3";
}

async Task DatTon(int ton)
{
    await using var db = new KhoDb(cs);
    await db.Database.ExecuteSqlAsync($"UPDATE dbo.SanPham SET TonKho = {ton} WHERE SanPhamId = 42");
}

async Task<int> DocTon()
{
    await using var db = new KhoDb(cs);
    return await db.SanPham.Where(p => p.SanPhamId == 42).Select(p => p.TonKho).SingleAsync();
}

public class SanPham
{
    public int SanPhamId { get; set; }
    public string MaSanPham { get; set; } = "";
    public int TonKho { get; set; }
    [Timestamp] public byte[] PhienBan { get; set; } = [];
}

public class DoanhThuNgay
{
    public DateTime Ngay { get; set; }
    public int SanPhamId { get; set; }
    public int SoLuong { get; set; }
    public decimal DoanhThu { get; set; }
}

public class KhoDb(string cs) : DbContext
{
    public DbSet<SanPham> SanPham => Set<SanPham>();
    public DbSet<DoanhThuNgay> DoanhThuNgay => Set<DoanhThuNgay>();
    protected override void OnConfiguring(DbContextOptionsBuilder o) => o.UseSqlServer(cs);
    protected override void OnModelCreating(ModelBuilder m)
    {
        m.Entity<SanPham>().ToTable("SanPham", "dbo");
        m.Entity<DoanhThuNgay>(e =>
        {
            e.ToTable("DoanhThuNgay", "dbo");
            e.HasKey(d => new { d.Ngay, d.SanPhamId });
            e.Property(d => d.Ngay).HasColumnType("date");
            e.Property(d => d.DoanhThu).HasColumnType("decimal(18, 2)");
        });
        if (GetType() == typeof(KhoDb)) m.Entity<SanPham>().Ignore(p => p.PhienBan);  // bản không có token
    }
}
public class KhoDbToken(string cs) : KhoDb(cs);

sealed class Gap(int soBen)
{
    int _con = soBen;
    readonly TaskCompletionSource _du = new(TaskCreationOptions.RunContinuationsAsynchronously);
    public Task DenAsync() { if (Interlocked.Decrement(ref _con) == 0) _du.SetResult(); return _du.Task; }
}

1. SaveChanges, không token:      bán 3, bán 3; tồn còn 2
2. SaveChanges, có [Timestamp]:   DbUpdateConcurrencyException, bán 3; tồn còn 2
3. ExecuteUpdateAsync có điều kiện: hết hàng, bán 3; tồn còn 2
4. FromSql với UPDLOCK:           đọc 5 sau 6 ms, bán 3 | đọc 2 sau 199 ms, hết hàng; tồn còn 2
5. FindAsync rồi Add:             ghi được, lỗi 2627; dòng (2026-10-03, 42) = (2, 500.000)
6. usp_DoanhThuNgay_Cong:         cả hai ghi được; dòng (2026-10-03, 42) = (4, 1.000.000)