// task를 먼저 시작해두고 한 번에 기다림
Task<User>    userTask   = LoadUserAsync();
Task<Order[]> orderTask  = LoadOrdersAsync();

await Task.WhenAll(userTask, orderTask); // 두 작업이 동시에 진행됨

User    user   = await userTask;    // 이미 완료됨 — 바로 반환
Order[] orders = await orderTask;

// 컬렉션 버전
string[] results = await Task.WhenAll(
    urls.Select(url => http.GetStringAsync(url)));

// ❌ 순차 — A(2초) + B(1초) = 3초
var user   = await LoadUserAsync();   // 2초 기다린 후
var orders = await LoadOrdersAsync(); // 1초 기다림 → 총 3초

// ✅ 동시 — max(A, B) = 2초
var userTask   = LoadUserAsync();     // 즉시 시작
var orderTask  = LoadOrdersAsync();   // 즉시 시작
await Task.WhenAll(userTask, orderTask); // 가장 오래 걸리는 것 = 2초

// ❌ Task.WhenAll 없이 순차 await만 하면 총 시간이 누적
var user = await LoadUserAsync();
var orders = await LoadOrdersAsync();

// ✅ task를 먼저 시작한 뒤 한 번에 기다림
var userTask = LoadUserAsync();
var orderTask = LoadOrdersAsync();
await Task.WhenAll(userTask, orderTask);

var t1 = Task.FromException(new InvalidOperationException("A 실패"));
var t2 = Task.FromException(new ArgumentException("B 실패"));

try
{
    await Task.WhenAll(t1, t2);
}
catch (Exception ex)
{
    // ex는 첫 번째 예외만
    Console.WriteLine(ex.Message); // "A 실패"

    // 모든 예외를 보려면 task를 직접 확인
    var allExceptions = new[] { t1, t2 }
        .Where(t => t.IsFaulted)
        .SelectMany(t => t.Exception!.InnerExceptions);
}

var fetchTask    = FetchDataAsync();
var timeoutTask  = Task.Delay(TimeSpan.FromSeconds(5));

var completed = await Task.WhenAny(fetchTask, timeoutTask);
if (completed == timeoutTask)
    throw new TimeoutException("5초 초과");

var result = await fetchTask; // 이미 완료됨

var semaphore = new SemaphoreSlim(maxConcurrency: 5);

var tasks = urls.Select(async url =>
{
    await semaphore.WaitAsync();
    try
    {
        return await http.GetStringAsync(url);
    }
    finally
    {
        semaphore.Release();
    }
});

string[] results = await Task.WhenAll(tasks);