타임아웃 패턴

using System;
using System.Threading;
using System.Threading.Tasks;

var inventory = new SlowInventory(TimeSpan.FromMilliseconds(1000));

// 호출자가 기다릴 시간을 정한다. 50 ms가 지나면 이 소스의 토큰이 취소된다.
using var timeout = new CancellationTokenSource();
timeout.CancelAfter(TimeSpan.FromMilliseconds(50));
try
{
    int quantity = await inventory.GetStockAsync("A-1", timeout.Token);
    Console.WriteLine($"stock: {quantity}");
}
catch (OperationCanceledException) when (timeout.IsCancellationRequested)
{
    Console.WriteLine("timed out");
}
Console.WriteLine($"work: {inventory.State}");

// 느린 재고 서비스를 흉내 낸다. 응답에 1000 ms가 걸리지만 취소 토큰을 따른다.
sealed class SlowInventory(TimeSpan delay)
{
    public string State { get; private set; } = "not started";

    public async Task<int> GetStockAsync(string sku, CancellationToken ct)
    {
        State = "running";
        // 취소 요청이 오면 Delay가 곧바로 끝난다. 예외 대신 토큰을 직접 확인하려고 SuppressThrowing을 쓴다.
        await Task.Delay(delay, ct).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
        if (ct.IsCancellationRequested)
        {
            // 열린 연결이나 잠금을 정리하는 자리다. 정리한 뒤 취소로 끝났음을 알린다.
            State = "stopped by cancellation";
            ct.ThrowIfCancellationRequested();
        }
        State = "completed";
        return 7;
    }
}

timed out
work: stopped by cancellation

using System;
using System.Threading;
using System.Threading.Tasks;

TimeSpan Ms(int value) => TimeSpan.FromMilliseconds(value);

// 1) WaitAsync: 호출자만 기다림을 멈춘다. 작업에는 취소 신호가 가지 않는다.
var abandoned = new FakeService("stock", Ms(1000));
Task<int> running = abandoned.GetAsync(CancellationToken.None);
try
{
    await running.WaitAsync(Ms(50));
}
catch (TimeoutException)
{
    Console.WriteLine($"WaitAsync: caller stopped waiting, work: {abandoned.State}");
}
int late = await running;
Console.WriteLine($"WaitAsync: abandoned work finished later with {late}, work: {abandoned.State}");

// 2) 연결된 토큰: 상위 취소와 이 호출의 제한 시간 중 먼저 오는 쪽이 작업을 멈춘다.
using (var request = new CancellationTokenSource())
{
    Console.WriteLine(await CallAsync(new FakeService("stock", Ms(1000)), request.Token, CancellationToken.None, Ms(50)));
}
using (var request = new CancellationTokenSource())
{
    request.CancelAfter(Ms(50)); // 예: 요청을 보낸 클라이언트가 연결을 끊었다.
    Console.WriteLine(await CallAsync(new FakeService("stock", Ms(1000)), request.Token, CancellationToken.None, Ms(5000)));
}

// 3) 공유 기한: 요청 전체에 500 ms를 주고, 기한 토큰 하나를 모든 하위 호출에 넘긴다.
using (var request = new CancellationTokenSource())
using (var deadline = new CancellationTokenSource(Ms(500)))
{
    Console.WriteLine(await CallAsync(new FakeService("price", Ms(30)), request.Token, deadline.Token, Ms(5000)));
    Console.WriteLine(await CallAsync(new FakeService("stock", Ms(10000)), request.Token, deadline.Token, Ms(5000)));
    Console.WriteLine(await CallAsync(new FakeService("ship", Ms(30)), request.Token, deadline.Token, Ms(5000)));
}

// 호출 하나에 자기 제한 시간을 걸고, 어떤 이유로 끝났는지 값으로 돌려준다.
// 상위 취소와 공유 기한은 따로 받아야 끝난 이유를 구분할 수 있다.
static async Task<CallResult> CallAsync(FakeService service, CancellationToken upstream, CancellationToken deadline, TimeSpan limit)
{
    // 이미 취소됐거나 기한이 지났으면 시작하지 않는다.
    if (upstream.IsCancellationRequested || deadline.IsCancellationRequested)
        return new CallResult(service.Name, CallStatus.NotStarted, service.State);

    using var linked = CancellationTokenSource.CreateLinkedTokenSource(upstream, deadline);
    linked.CancelAfter(limit);
    try
    {
        await service.GetAsync(linked.Token);
        return new CallResult(service.Name, CallStatus.Ok, service.State);
    }
    catch (OperationCanceledException) when (upstream.IsCancellationRequested)
    {
        // 사용자가 취소했다. 의존성의 실패가 아니다.
        return new CallResult(service.Name, CallStatus.UpstreamCanceled, service.State);
    }
    catch (OperationCanceledException) when (deadline.IsCancellationRequested)
    {
        // 요청 전체의 기한이 다 됐다.
        return new CallResult(service.Name, CallStatus.DeadlineExceeded, service.State);
    }
    catch (OperationCanceledException) when (linked.IsCancellationRequested)
    {
        // 이 호출의 제한 시간이 지났다.
        return new CallResult(service.Name, CallStatus.TimedOut, service.State);
    }
}

enum CallStatus { Ok, TimedOut, DeadlineExceeded, UpstreamCanceled, NotStarted }

sealed record CallResult(string Name, CallStatus Status, string Work)
{
    public override string ToString() => $"{Name}: {Status}, work: {Work}";
}

// 느린 의존성을 흉내 낸다. 정해진 시간이 걸리지만 취소 토큰을 따른다.
sealed class FakeService(string name, TimeSpan delay)
{
    public string Name => name;
    public string State { get; private set; } = "not started";

    public async Task<int> GetAsync(CancellationToken ct)
    {
        State = "running";
        // 취소 요청이 오면 Delay가 곧바로 끝난다. 예외 대신 토큰을 직접 확인하려고 SuppressThrowing을 쓴다.
        await Task.Delay(delay, ct).ConfigureAwait(ConfigureAwaitOptions.SuppressThrowing);
        if (ct.IsCancellationRequested)
        {
            // 열린 연결이나 잠금을 정리하는 자리다. 정리한 뒤 취소로 끝났음을 알린다.
            State = "stopped by cancellation";
            ct.ThrowIfCancellationRequested();
        }
        State = "completed";
        return 7;
    }
}

WaitAsync: caller stopped waiting, work: running
WaitAsync: abandoned work finished later with 7, work: completed
stock: TimedOut, work: stopped by cancellation
stock: UpstreamCanceled, work: stopped by cancellation
price: Ok, work: completed
stock: DeadlineExceeded, work: stopped by cancellation
ship: NotStarted, work: not started

// 느린 의존성을 흉내 낸다. delayMs가 걸리지만 AbortSignal을 따른다.
class FakeService {
  state = "not started";
  constructor(readonly name: string, private readonly delayMs: number) {}

  get(signal: AbortSignal): Promise<number> {
    return new Promise((resolve, reject) => {
      if (signal.aborted) {
        reject(signal.reason);
        return;
      }
      this.state = "running";
      const onAbort = () => {
        // 타이머를 지우는 것이 실제로 작업을 멈추는 부분이다.
        clearTimeout(timer);
        this.state = "stopped by abort";
        reject(signal.reason);
      };
      const timer = setTimeout(() => {
        signal.removeEventListener("abort", onAbort);
        this.state = "completed";
        resolve(7);
      }, this.delayMs);
      signal.addEventListener("abort", onAbort, { once: true });
    });
  }
}

// 중단 이유를 값으로 바꾼다. 타임아웃은 TimeoutError, abort()는 AbortError다.
function reasonOf(e: unknown): string {
  if (e instanceof DOMException && e.name === "TimeoutError") return "timed out";
  if (e instanceof DOMException && e.name === "AbortError") return "canceled by caller";
  return "failed";
}

async function call(service: FakeService, signal: AbortSignal): Promise<string> {
  try {
    await service.get(signal);
    return `${service.name}: ok, work: ${service.state}`;
  } catch (e) {
    return `${service.name}: ${reasonOf(e)}, work: ${service.state}`;
  }
}

async function main(): Promise<void> {
  // 1) AbortSignal.timeout: 50 ms 뒤 신호가 중단되고 작업이 그 신호를 받아 멈춘다.
  console.log(await call(new FakeService("stock", 1000), AbortSignal.timeout(50)));

  // 2) 기다림만 끊기: 작업에 신호를 주지 않으면 작업은 계속 돈다.
  const abandoned = new FakeService("stock", 1000);
  const running = abandoned.get(new AbortController().signal);
  const timer = new Promise<"timeout">((resolve) => setTimeout(() => resolve("timeout"), 50));
  const first = await Promise.race([running, timer]);
  console.log(`race: ${first}, work: ${abandoned.state}`);
  console.log(`race: abandoned work finished later with ${await running}, work: ${abandoned.state}`);

  // 3) 신호 합치기: 호출자의 취소와 타임아웃 중 먼저 오는 쪽이 작업을 멈춘다.
  const caller = new AbortController();
  setTimeout(() => caller.abort(), 50);
  const combined = AbortSignal.any([caller.signal, AbortSignal.timeout(5000)]);
  console.log(await call(new FakeService("stock", 1000), combined));
}

main();

stock: timed out, work: stopped by abort
race: timeout, work: running
race: abandoned work finished later with 7, work: completed
stock: canceled by caller, work: stopped by abort