가드 클로즈

using System;
using System.Globalization;

var orders = new (int Items, decimal Subtotal, bool Member)[]
{
    (0, 0m, false),
    (2, 30m, true),
    (3, 80m, false),
    (1, 20m, false),
};
foreach (var (items, subtotal, member) in orders)
{
    var nested = ShippingNested(items, subtotal, member);
    var guarded = ShippingGuarded(items, subtotal, member);
    var who = member ? "member" : "guest";
    var amount = subtotal.ToString(CultureInfo.InvariantCulture);
    Console.WriteLine($"items={items} subtotal={amount} {who}: {guarded} (same: {nested == guarded})");
}

// 중첩 if: 기본 배송비라는 정상 경로가 가장 깊은 곳에 있다.
static string ShippingNested(int items, decimal subtotal, bool member)
{
    string result;
    if (items > 0)
    {
        if (!member)
        {
            if (subtotal < 50m)
            {
                result = "fee 5";
            }
            else
            {
                result = "free (over 50)";
            }
        }
        else
        {
            result = "free (member)";
        }
    }
    else
    {
        result = "rejected: empty order";
    }
    return result;
}

// 가드 클로즈: 특별한 경우를 먼저 처리하고 바로 반환한다.
static string ShippingGuarded(int items, decimal subtotal, bool member)
{
    if (items <= 0) return "rejected: empty order";
    if (member) return "free (member)";
    if (subtotal >= 50m) return "free (over 50)";
    return "fee 5";
}

items=0 subtotal=0 guest: rejected: empty order (same: True)
items=2 subtotal=30 member: free (member) (same: True)
items=3 subtotal=80 guest: free (over 50) (same: True)
items=1 subtotal=20 guest: fee 5 (same: True)

using System;
using System.Collections.Generic;

var orders = new Dictionary<string, Order>
{
    ["order-1"] = new Order("alice", OrderStatus.Placed),
    ["order-2"] = new Order("alice", OrderStatus.Shipped),
    ["order-3"] = new Order("alice", OrderStatus.Placed),
};
var alice = new User("alice", IsAdmin: false);
var bob = new User("bob", IsAdmin: false);
var carol = new User("carol", IsAdmin: true);
var handler = new CancelOrderHandler(orders);

var requests = new (CancelOrder Command, User Actor)[]
{
    (new CancelOrder("order-1", "changed mind"), alice),
    (new CancelOrder("order-1", "changed mind"), alice),
    (new CancelOrder("order-2", "too slow"), bob),
    (new CancelOrder("order-2", "customer call"), carol),
    (new CancelOrder("order-9", "typo"), alice),
    (new CancelOrder("order-3", "   "), alice),
    (new CancelOrder("order-3", null), alice),
};
foreach (var (command, actor) in requests)
{
    var result = handler.Handle(command, actor);
    var text = result.Failure is { } f ? $"Err {f.Code} at {f.Stage}" : $"Ok {result.Value}";
    Console.WriteLine($"{actor.Id} cancels {command.OrderId}: {text}");
}

// null 명령은 호출 코드의 버그다. 데모에서만 잡아서 출력한다.
try
{
    handler.Handle(null!, alice);
}
catch (ArgumentNullException ex)
{
    Console.WriteLine($"bug: {ex.GetType().Name} ({ex.ParamName})");
}

enum OrderStatus { Placed, Shipped, Cancelled }
enum ErrorCode { ReasonMissing, OrderNotFound, PermissionDenied, AlreadyShipped, AlreadyCancelled }
enum Stage { Validate, Load, Authorize, Rule }

sealed record User(string Id, bool IsAdmin);
sealed record CancelOrder(string OrderId, string? Reason);
sealed class Order(string ownerId, OrderStatus status)
{
    public string OwnerId { get; } = ownerId;
    public OrderStatus Status { get; set; } = status;
    public string? CancelReason { get; set; }
}

sealed record Failure(ErrorCode Code, Stage Stage);
// Failure가 null이면 성공이다. T가 값 타입이면 실패 결과의 Value에는 default(T)가 들어 있다.
sealed record Result<T>(T? Value, Failure? Failure)
{
    public static Result<T> Ok(T value) => new(value, null);
    public static Result<T> Fail(ErrorCode code, Stage stage) => new(default, new Failure(code, stage));
}

sealed class CancelOrderHandler(Dictionary<string, Order> orders)
{
    public Result<OrderStatus> Handle(CancelOrder command, User actor)
    {
        // 호출 규약 위반은 프로그래밍 오류이므로 예외를 던진다.
        ArgumentNullException.ThrowIfNull(command);
        ArgumentNullException.ThrowIfNull(actor);

        // 1. 입력 검사: 저장소를 보지 않아도 판단할 수 있다.
        //    빈 사유를 기본 문구로 바꾸지 않고 거절한다.
        if (string.IsNullOrWhiteSpace(command.Reason))
            return Result<OrderStatus>.Fail(ErrorCode.ReasonMissing, Stage.Validate);

        // 2. 대상 조회
        if (!orders.TryGetValue(command.OrderId, out var order))
            return Result<OrderStatus>.Fail(ErrorCode.OrderNotFound, Stage.Load);

        // 3. 권한: 주문 상태를 알려 주기 전에 확인한다.
        if (order.OwnerId != actor.Id && !actor.IsAdmin)
            return Result<OrderStatus>.Fail(ErrorCode.PermissionDenied, Stage.Authorize);

        // 4. 업무 규칙
        if (order.Status == OrderStatus.Shipped)
            return Result<OrderStatus>.Fail(ErrorCode.AlreadyShipped, Stage.Rule);
        if (order.Status == OrderStatus.Cancelled)
            return Result<OrderStatus>.Fail(ErrorCode.AlreadyCancelled, Stage.Rule);

        // 정상 경로: 모든 가드를 통과한 경우만 여기에 온다.
        order.Status = OrderStatus.Cancelled;
        order.CancelReason = command.Reason;
        return Result<OrderStatus>.Ok(order.Status);
    }
}

alice cancels order-1: Ok Cancelled
alice cancels order-1: Err AlreadyCancelled at Rule
bob cancels order-2: Err PermissionDenied at Authorize
carol cancels order-2: Err AlreadyShipped at Rule
alice cancels order-9: Err OrderNotFound at Load
alice cancels order-3: Err ReasonMissing at Validate
alice cancels order-3: Err ReasonMissing at Validate
bug: ArgumentNullException (command)

type OrderStatus = "Placed" | "Shipped" | "Cancelled";
type ErrorCode = "ReasonMissing" | "OrderNotFound" | "PermissionDenied" | "AlreadyShipped" | "AlreadyCancelled";
type Stage = "Validate" | "Load" | "Authorize" | "Rule";

interface User { readonly id: string; readonly isAdmin: boolean; }
interface CancelOrder { readonly orderId: string; readonly reason?: string; }
interface Order { readonly ownerId: string; status: OrderStatus; cancelReason: string | null; }

// ok 필드로 성공과 실패를 구분하는 판별 유니온
type Result<T> =
  | { readonly ok: true; readonly value: T }
  | { readonly ok: false; readonly code: ErrorCode; readonly stage: Stage };

const fail = (code: ErrorCode, stage: Stage): Result<never> => ({ ok: false, code, stage });

class CancelOrderHandler {
  constructor(private readonly orders: Map<string, Order>) {}

  handle(command: CancelOrder, actor: User): Result<OrderStatus> {
    const reason = command.reason; // string | undefined
    // 1. 입력 검사: 빈 사유를 기본 문구로 바꾸지 않고 거절한다.
    if (reason === undefined || reason.trim() === "") return fail("ReasonMissing", "Validate");
    // 여기부터 reason은 string으로 좁혀진다.

    const order = this.orders.get(command.orderId); // Order | undefined
    // 2. 대상 조회
    if (order === undefined) return fail("OrderNotFound", "Load");
    // 여기부터 order는 Order로 좁혀진다.

    // 3. 권한: 주문 상태를 알려 주기 전에 확인한다.
    if (order.ownerId !== actor.id && !actor.isAdmin) return fail("PermissionDenied", "Authorize");

    // 4. 업무 규칙
    if (order.status === "Shipped") return fail("AlreadyShipped", "Rule");
    if (order.status === "Cancelled") return fail("AlreadyCancelled", "Rule");

    // 정상 경로: reason은 string, order는 Order로 좁혀져 있어 단언이 필요 없다.
    order.status = "Cancelled";
    order.cancelReason = reason;
    return { ok: true, value: order.status };
  }
}

const orders = new Map<string, Order>([
  ["order-1", { ownerId: "alice", status: "Placed", cancelReason: null }],
  ["order-2", { ownerId: "alice", status: "Shipped", cancelReason: null }],
  ["order-3", { ownerId: "alice", status: "Placed", cancelReason: null }],
]);
const alice: User = { id: "alice", isAdmin: false };
const bob: User = { id: "bob", isAdmin: false };
const carol: User = { id: "carol", isAdmin: true };
const handler = new CancelOrderHandler(orders);

const requests: ReadonlyArray<readonly [CancelOrder, User]> = [
  [{ orderId: "order-1", reason: "changed mind" }, alice],
  [{ orderId: "order-1", reason: "changed mind" }, alice],
  [{ orderId: "order-2", reason: "too slow" }, bob],
  [{ orderId: "order-2", reason: "customer call" }, carol],
  [{ orderId: "order-9", reason: "typo" }, alice],
  [{ orderId: "order-3", reason: "   " }, alice],
  [{ orderId: "order-3" }, alice],
];
for (const [command, actor] of requests) {
  const result = handler.handle(command, actor);
  if (!result.ok) {
    // 이 분기에서는 code와 stage만 쓸 수 있다.
    console.log(`${actor.id} cancels ${command.orderId}: Err ${result.code} at ${result.stage}`);
    continue;
  }
  console.log(`${actor.id} cancels ${command.orderId}: Ok ${result.value}`);
}

alice cancels order-1: Ok Cancelled
alice cancels order-1: Err AlreadyCancelled at Rule
bob cancels order-2: Err PermissionDenied at Authorize
carol cancels order-2: Err AlreadyShipped at Rule
alice cancels order-9: Err OrderNotFound at Load
alice cancels order-3: Err ReasonMissing at Validate
alice cancels order-3: Err ReasonMissing at Validate