작업 단위 패턴

using System;
using System.Collections.Generic;
using System.Linq;

var store = new Store();
store.Seed(new Row("products", "p1", "stock=5", 1));
store.Seed(new Row("cart_items", "c1", "p1 x2", 1));

var uow = new UnitOfWork(store);
// 등록만 하고 저장소에는 아직 쓰지 않는다. 주문 항목을 주문보다 먼저 등록했다.
uow.RegisterNew(new Row("order_lines", "l1", "o1 p1 x2", 0));
uow.RegisterNew(new Row("orders", "o1", "placed", 0));
uow.RegisterDirty(new Row("products", "p1", "stock=3", 1));
uow.RegisterRemoved(new Row("cart_items", "c1", "", 1));
Console.WriteLine("store calls before commit: " + store.Calls);
foreach (var change in uow.Plan()) Console.WriteLine("plan: " + change);
Console.WriteLine("commit: " + uow.Commit());
Console.WriteLine("store calls after commit: " + store.Calls);
foreach (var row in store.Rows()) Console.WriteLine("row: " + row);

enum Kind { Insert, Update, Delete }
sealed record Row(string Table, string Id, string Data, int Version)
{
    public override string ToString() => $"{Table}/{Id} v{Version} {Data}";
}
sealed record Change(Kind Kind, Row Row)
{
    public override string ToString() => $"{Kind.ToString().ToUpperInvariant()} {Row.Table}/{Row.Id}";
}
abstract record CommitResult;
sealed record Committed(int Changes) : CommitResult;
sealed record Rejected(string Code, string Key, string Detail) : CommitResult;

// 메모리 저장소. Apply 한 번을 트랜잭션 하나처럼 다룬다.
sealed class Store
{
    private Dictionary<string, Row> rows = new();
    public int Calls { get; private set; }
    public void Seed(Row row) => rows[Key(row)] = row;
    public IEnumerable<Row> Rows() => rows.Values.OrderBy(Key, StringComparer.Ordinal);

    // 사본에 차례로 적용하고, 전부 성공했을 때만 사본으로 바꿔 끼운다.
    public CommitResult Apply(IReadOnlyList<Change> changes)
    {
        Calls++;
        var draft = new Dictionary<string, Row>(rows);
        foreach (var change in changes)
        {
            var rejected = ApplyOne(draft, change);
            if (rejected is not null) return rejected;
        }
        rows = draft;
        return new Committed(changes.Count);
    }

    private static Rejected? ApplyOne(Dictionary<string, Row> draft, Change change)
    {
        var key = Key(change.Row);
        var exists = draft.TryGetValue(key, out var current);
        if (change.Kind == Kind.Insert)
        {
            if (exists) return new Rejected("DuplicateKey", key, "row already exists");
            draft[key] = change.Row with { Version = 1 };
            return null;
        }
        // 수정과 삭제는 읽었던 버전이 지금도 같을 때만 적용한다.
        if (current is null) return new Rejected("VersionConflict", key, $"read v{change.Row.Version}, store missing");
        if (current.Version != change.Row.Version)
            return new Rejected("VersionConflict", key, $"read v{change.Row.Version}, store v{current.Version}");
        if (change.Kind == Kind.Delete) draft.Remove(key);
        else draft[key] = change.Row with { Version = current.Version + 1 };
        return null;
    }

    private static string Key(Row row) => row.Table + "/" + row.Id;
}

// 작업 단위: 새 행, 바뀐 행, 지울 행을 모아 두었다가 한 번에 보낸다.
sealed class UnitOfWork(Store store)
{
    // 부모 테이블을 앞에 둔다. 넣을 때는 앞에서부터, 지울 때는 뒤에서부터 처리한다.
    private static readonly string[] TableOrder = ["products", "orders", "order_lines", "cart_items"];
    private readonly List<Row> added = new();
    private readonly List<Row> dirty = new();
    private readonly List<Row> removed = new();

    public void RegisterNew(Row row) => added.Add(row);
    public void RegisterDirty(Row row) => dirty.Add(row);
    public void RegisterRemoved(Row row) => removed.Add(row);

    public IReadOnlyList<Change> Plan() =>
        added.OrderBy(Rank).Select(r => new Change(Kind.Insert, r))
            .Concat(dirty.OrderBy(Rank).Select(r => new Change(Kind.Update, r)))
            .Concat(removed.OrderByDescending(Rank).Select(r => new Change(Kind.Delete, r)))
            .ToList();

    public CommitResult Commit()
    {
        // 순서를 정할 수 없는 테이블이 있으면 저장소를 부르지 않고 거부한다.
        var unknown = added.Concat(dirty).Concat(removed).FirstOrDefault(r => Rank(r) < 0);
        if (unknown is not null)
            return new Rejected("UnknownTable", unknown.Table + "/" + unknown.Id, "table has no commit order");
        var result = store.Apply(Plan());
        if (result is not Committed) return result;
        added.Clear();
        dirty.Clear();
        removed.Clear();
        return result;
    }

    private static int Rank(Row row) => Array.IndexOf(TableOrder, row.Table);
}

store calls before commit: 0
plan: INSERT orders/o1
plan: INSERT order_lines/l1
plan: UPDATE products/p1
plan: DELETE cart_items/c1
commit: Committed { Changes = 4 }
store calls after commit: 1
row: order_lines/l1 v1 o1 p1 x2
row: orders/o1 v1 placed
row: products/p1 v2 stock=3

using System;
using System.Collections.Generic;
using System.Linq;

var order = new Row("orders", "o1", "placed", 0);
var line = new Row("order_lines", "l1", "o1 p1 x2", 0);
var stock = new Row("products", "p1", "stock=3", 1);
var cart = new Row("cart_items", "c1", "", 1);

Console.WriteLine("== immediate writes");
var direct = NewStoreWithConcurrentChange();
var callsBefore = direct.Calls;
// 변경마다 저장소를 부르고, 실패하면 그 자리에서 멈춘다.
Change[] steps =
[
    new(Kind.Insert, order),
    new(Kind.Insert, line),
    new(Kind.Update, stock),
    new(Kind.Delete, cart),
];
foreach (var step in steps)
{
    var result = direct.Apply([step]);
    Console.WriteLine(step + ": " + result);
    if (result is not Committed) break;
}
Console.WriteLine("store calls: " + (direct.Calls - callsBefore));
Dump("after", direct);

Console.WriteLine("== unit of work");
var store = NewStoreWithConcurrentChange();
callsBefore = store.Calls;
Dump("before", store);
var uow = new UnitOfWork(store);
uow.RegisterNew(order);
uow.RegisterNew(line);
uow.RegisterDirty(stock);
uow.RegisterRemoved(cart);
var commit = uow.Commit();
Console.WriteLine("commit: " + Describe(commit));
Console.WriteLine("store calls: " + (store.Calls - callsBefore));
Dump("after", store);

Console.WriteLine("== unknown table");
callsBefore = store.Calls;
var audit = new UnitOfWork(store);
audit.RegisterNew(new Row("audit_log", "a1", "order o1 placed", 0));
Console.WriteLine("commit: " + Describe(audit.Commit()));
Console.WriteLine("store calls: " + (store.Calls - callsBefore));

// 상품 p1을 v1으로 읽은 뒤, 다른 요청이 먼저 재고를 바꿔 v2가 된 저장소를 만든다.
static Store NewStoreWithConcurrentChange()
{
    var s = new Store();
    s.Seed(new Row("products", "p1", "stock=5", 1));
    s.Seed(new Row("cart_items", "c1", "p1 x2", 1));
    s.Apply([new Change(Kind.Update, new Row("products", "p1", "stock=4", 1))]);
    return s;
}

// 실패는 예외가 아니라 결과 값으로 돌아온다. 다시 읽고 다시 계산할지는 호출자가 정한다.
static string Describe(CommitResult result) => result switch
{
    Committed ok => $"committed {ok.Changes} changes",
    Rejected no => $"rejected {no.Code} at {no.Key} ({no.Detail})",
    _ => "unknown result",
};

static void Dump(string label, Store s)
{
    foreach (var row in s.Rows()) Console.WriteLine(label + ": " + row);
}

enum Kind { Insert, Update, Delete }
sealed record Row(string Table, string Id, string Data, int Version)
{
    public override string ToString() => $"{Table}/{Id} v{Version} {Data}";
}
sealed record Change(Kind Kind, Row Row)
{
    public override string ToString() => $"{Kind.ToString().ToUpperInvariant()} {Row.Table}/{Row.Id}";
}
abstract record CommitResult;
sealed record Committed(int Changes) : CommitResult;
sealed record Rejected(string Code, string Key, string Detail) : CommitResult;

// 메모리 저장소. Apply 한 번을 트랜잭션 하나처럼 다룬다.
sealed class Store
{
    private Dictionary<string, Row> rows = new();
    public int Calls { get; private set; }
    public void Seed(Row row) => rows[Key(row)] = row;
    public IEnumerable<Row> Rows() => rows.Values.OrderBy(Key, StringComparer.Ordinal);

    // 사본에 차례로 적용하고, 전부 성공했을 때만 사본으로 바꿔 끼운다.
    public CommitResult Apply(IReadOnlyList<Change> changes)
    {
        Calls++;
        var draft = new Dictionary<string, Row>(rows);
        foreach (var change in changes)
        {
            var rejected = ApplyOne(draft, change);
            if (rejected is not null) return rejected;
        }
        rows = draft;
        return new Committed(changes.Count);
    }

    private static Rejected? ApplyOne(Dictionary<string, Row> draft, Change change)
    {
        var key = Key(change.Row);
        var exists = draft.TryGetValue(key, out var current);
        if (change.Kind == Kind.Insert)
        {
            if (exists) return new Rejected("DuplicateKey", key, "row already exists");
            draft[key] = change.Row with { Version = 1 };
            return null;
        }
        // 수정과 삭제는 읽었던 버전이 지금도 같을 때만 적용한다.
        if (current is null) return new Rejected("VersionConflict", key, $"read v{change.Row.Version}, store missing");
        if (current.Version != change.Row.Version)
            return new Rejected("VersionConflict", key, $"read v{change.Row.Version}, store v{current.Version}");
        if (change.Kind == Kind.Delete) draft.Remove(key);
        else draft[key] = change.Row with { Version = current.Version + 1 };
        return null;
    }

    private static string Key(Row row) => row.Table + "/" + row.Id;
}

// 작업 단위: 새 행, 바뀐 행, 지울 행을 모아 두었다가 한 번에 보낸다.
sealed class UnitOfWork(Store store)
{
    // 부모 테이블을 앞에 둔다. 넣을 때는 앞에서부터, 지울 때는 뒤에서부터 처리한다.
    private static readonly string[] TableOrder = ["products", "orders", "order_lines", "cart_items"];
    private readonly List<Row> added = new();
    private readonly List<Row> dirty = new();
    private readonly List<Row> removed = new();

    public void RegisterNew(Row row) => added.Add(row);
    public void RegisterDirty(Row row) => dirty.Add(row);
    public void RegisterRemoved(Row row) => removed.Add(row);

    public IReadOnlyList<Change> Plan() =>
        added.OrderBy(Rank).Select(r => new Change(Kind.Insert, r))
            .Concat(dirty.OrderBy(Rank).Select(r => new Change(Kind.Update, r)))
            .Concat(removed.OrderByDescending(Rank).Select(r => new Change(Kind.Delete, r)))
            .ToList();

    public CommitResult Commit()
    {
        // 순서를 정할 수 없는 테이블이 있으면 저장소를 부르지 않고 거부한다.
        var unknown = added.Concat(dirty).Concat(removed).FirstOrDefault(r => Rank(r) < 0);
        if (unknown is not null)
            return new Rejected("UnknownTable", unknown.Table + "/" + unknown.Id, "table has no commit order");
        var result = store.Apply(Plan());
        if (result is not Committed) return result;
        added.Clear();
        dirty.Clear();
        removed.Clear();
        return result;
    }

    private static int Rank(Row row) => Array.IndexOf(TableOrder, row.Table);
}

== immediate writes
INSERT orders/o1: Committed { Changes = 1 }
INSERT order_lines/l1: Committed { Changes = 1 }
UPDATE products/p1: Rejected { Code = VersionConflict, Key = products/p1, Detail = read v1, store v2 }
store calls: 3
after: cart_items/c1 v1 p1 x2
after: order_lines/l1 v1 o1 p1 x2
after: orders/o1 v1 placed
after: products/p1 v2 stock=4
== unit of work
before: cart_items/c1 v1 p1 x2
before: products/p1 v2 stock=4
commit: rejected VersionConflict at products/p1 (read v1, store v2)
store calls: 1
after: cart_items/c1 v1 p1 x2
after: products/p1 v2 stock=4
== unknown table
commit: rejected UnknownTable at audit_log/a1 (table has no commit order)
store calls: 0

type Kind = "INSERT" | "UPDATE" | "DELETE";
type Row = { table: string; id: string; data: string; version: number };
type Change = { kind: Kind; row: Row };
type CommitResult =
  | { ok: true; changes: number }
  | { ok: false; code: "DuplicateKey" | "VersionConflict" | "UnknownTable"; key: string; detail: string };

const keyOf = (row: Row): string => `${row.table}/${row.id}`;
const show = (row: Row): string => `${keyOf(row)} v${row.version} ${row.data}`;

// 메모리 저장소. apply 한 번을 트랜잭션 하나처럼 다룬다.
class Store {
  #rows = new Map<string, Row>();
  calls = 0;
  seed(row: Row): void { this.#rows.set(keyOf(row), row); }
  rows(): Row[] { return [...this.#rows.values()].sort((a, b) => (keyOf(a) < keyOf(b) ? -1 : 1)); }

  // 사본에 차례로 적용하고, 전부 성공했을 때만 사본으로 바꿔 끼운다.
  apply(changes: Change[]): CommitResult {
    this.calls++;
    const draft = new Map(this.#rows);
    for (const change of changes) {
      const rejected = applyOne(draft, change);
      if (rejected !== null) return rejected;
    }
    this.#rows = draft;
    return { ok: true, changes: changes.length };
  }
}

function applyOne(draft: Map<string, Row>, change: Change): CommitResult | null {
  const key = keyOf(change.row);
  const current = draft.get(key);
  if (change.kind === "INSERT") {
    if (current !== undefined) return { ok: false, code: "DuplicateKey", key, detail: "row already exists" };
    draft.set(key, { ...change.row, version: 1 });
    return null;
  }
  // 수정과 삭제는 읽었던 버전이 지금도 같을 때만 적용한다.
  if (current === undefined)
    return { ok: false, code: "VersionConflict", key, detail: `read v${change.row.version}, store missing` };
  if (current.version !== change.row.version)
    return { ok: false, code: "VersionConflict", key, detail: `read v${change.row.version}, store v${current.version}` };
  if (change.kind === "DELETE") draft.delete(key);
  else draft.set(key, { ...change.row, version: current.version + 1 });
  return null;
}

// 작업 단위: 새 행, 바뀐 행, 지울 행을 모아 두었다가 한 번에 보낸다.
class UnitOfWork {
  // 부모 테이블을 앞에 둔다. 넣을 때는 앞에서부터, 지울 때는 뒤에서부터 처리한다.
  static readonly tableOrder = ["products", "orders", "order_lines", "cart_items"];
  #added: Row[] = [];
  #dirty: Row[] = [];
  #removed: Row[] = [];
  constructor(private readonly store: Store) {}

  registerNew(row: Row): void { this.#added.push(row); }
  registerDirty(row: Row): void { this.#dirty.push(row); }
  registerRemoved(row: Row): void { this.#removed.push(row); }

  plan(): Change[] {
    const byRank = (a: Row, b: Row): number => UnitOfWork.rank(a) - UnitOfWork.rank(b);
    return [
      ...[...this.#added].sort(byRank).map((row): Change => ({ kind: "INSERT", row })),
      ...[...this.#dirty].sort(byRank).map((row): Change => ({ kind: "UPDATE", row })),
      ...[...this.#removed].sort((a, b) => byRank(b, a)).map((row): Change => ({ kind: "DELETE", row })),
    ];
  }

  commit(): CommitResult {
    // 순서를 정할 수 없는 테이블이 있으면 저장소를 부르지 않고 거부한다.
    const unknown = [...this.#added, ...this.#dirty, ...this.#removed].find((row) => UnitOfWork.rank(row) < 0);
    if (unknown !== undefined)
      return { ok: false, code: "UnknownTable", key: keyOf(unknown), detail: "table has no commit order" };
    const result = this.store.apply(this.plan());
    if (!result.ok) return result;
    this.#added = [];
    this.#dirty = [];
    this.#removed = [];
    return result;
  }

  static rank(row: Row): number { return UnitOfWork.tableOrder.indexOf(row.table); }
}

// 상품 p1을 v1으로 읽은 뒤, 다른 요청이 먼저 재고를 바꿔 v2가 된 저장소를 만든다.
const store = new Store();
store.seed({ table: "products", id: "p1", data: "stock=5", version: 1 });
store.seed({ table: "cart_items", id: "c1", data: "p1 x2", version: 1 });
store.apply([{ kind: "UPDATE", row: { table: "products", id: "p1", data: "stock=4", version: 1 } }]);
const callsBefore = store.calls;
for (const row of store.rows()) console.log("before: " + show(row));

const uow = new UnitOfWork(store);
uow.registerNew({ table: "order_lines", id: "l1", data: "o1 p1 x2", version: 0 });
uow.registerNew({ table: "orders", id: "o1", data: "placed", version: 0 });
uow.registerDirty({ table: "products", id: "p1", data: "stock=3", version: 1 });
uow.registerRemoved({ table: "cart_items", id: "c1", data: "", version: 1 });
for (const change of uow.plan()) console.log(`plan: ${change.kind} ${keyOf(change.row)}`);

const result = uow.commit();
// 실패는 예외가 아니라 결과 값으로 돌아온다. 다시 읽고 다시 계산할지는 호출자가 정한다.
console.log(result.ok
  ? `commit: committed ${result.changes} changes`
  : `commit: rejected ${result.code} at ${result.key} (${result.detail})`);
console.log("store calls: " + (store.calls - callsBefore));
for (const row of store.rows()) console.log("after: " + show(row));

before: cart_items/c1 v1 p1 x2
before: products/p1 v2 stock=4
plan: INSERT orders/o1
plan: INSERT order_lines/l1
plan: UPDATE products/p1
plan: DELETE cart_items/c1
commit: rejected VersionConflict at products/p1 (read v1, store v2)
store calls: 1
after: cart_items/c1 v1 p1 x2
after: products/p1 v2 stock=4