์ฝ˜ํ…์ธ  ๋Œ€ํ‘œ ์ด๋ฏธ์ง€ - ๐Ÿš€ C# ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ async/await, Task๋ฅผ ํ†ตํ•œ ๊ณ ์„ฑ๋Šฅ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ๊ฐœ๋ฐœ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

๐Ÿš€ C# ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ async/await, Task๋ฅผ ํ†ตํ•œ ๊ณ ์„ฑ๋Šฅ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ๊ฐœ๋ฐœ ์™„๋ฒฝ ๊ฐ€์ด๋“œ

์นœ๊ตฌ์ฒ˜๋Ÿผ ์‰ฝ๊ฒŒ ๋ฐฐ์šฐ๋Š” ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๋ชจ๋“  ๊ฒƒ

์•ˆ๋…•! ๐Ÿ‘‹ ์˜ค๋Š˜์€ C# ๊ฐœ๋ฐœ์ž๋ผ๋ฉด ๋ฐ˜๋“œ์‹œ ์•Œ์•„์•ผ ํ•  ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์— ๋Œ€ํ•ด ์ด์•ผ๊ธฐํ•ด๋ณผ๊ฒŒ. ํ˜น์‹œ ํ”„๋กœ๊ทธ๋žจ์ด ๋ฉˆ์ถ˜ ๊ฒƒ์ฒ˜๋Ÿผ ๋А๊ปด์ง€๊ฑฐ๋‚˜, ์‚ฌ์šฉ์ž๊ฐ€ ๋ฒ„ํŠผ์„ ๋ˆŒ๋ €๋Š”๋ฐ ํ•œ์ฐธ์„ ๊ธฐ๋‹ค๋ ค์•ผ ํ•˜๋Š” ๊ฒฝํ—˜ ์žˆ์ง€? ๐Ÿ˜ฐ ๋ฐ”๋กœ ๊ทธ๋Ÿฐ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๊ฒŒ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด์•ผ!

์š”์ฆ˜ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์€ ๋„คํŠธ์›Œํฌ ํ†ต์‹ , ํŒŒ์ผ ์ž…์ถœ๋ ฅ, ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์ฟผ๋ฆฌ ๋“ฑ ์‹œ๊ฐ„์ด ๊ฑธ๋ฆฌ๋Š” ์ž‘์—…๋“ค์„ ์—„์ฒญ ๋งŽ์ด ํ•ด. ์ด๋Ÿฐ ์ž‘์—…๋“ค์„ ํšจ์œจ์ ์œผ๋กœ ์ฒ˜๋ฆฌํ•˜์ง€ ๋ชปํ•˜๋ฉด ์‚ฌ์šฉ์ž ๊ฒฝํ—˜์ด ์ตœ์•…์ด ๋˜์ง€. ๐Ÿ˜ฑ ๊ทธ๋ž˜์„œ ๋“ฑ์žฅํ•œ ๊ฒŒ ๋ฐ”๋กœ async/await์™€ Task์•ผ!

๐ŸŽฏ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด ๋ญ๊ธธ๋ž˜?

๋จผ์ € ๊ธฐ๋ณธ ๊ฐœ๋…๋ถ€ํ„ฐ ํ™•์‹คํžˆ ์žก๊ณ  ๊ฐ€์ž! ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์ดํ•ดํ•˜๋ ค๋ฉด ๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ๊ณผ ๋น„๊ตํ•ด๋ณด๋Š” ๊ฒŒ ์ œ์ผ ์ข‹์•„.

๋™๊ธฐ(Synchronous) ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ๋งˆ์น˜ ์ค„์„ ์„œ์„œ ๊ธฐ๋‹ค๋ฆฌ๋Š” ๊ฒƒ๊ณผ ๊ฐ™์•„. ๐Ÿšถโ€โ™‚๏ธ๐Ÿšถโ€โ™€๏ธ๐Ÿšถ ํ•œ ์ž‘์—…์ด ๋๋‚˜์•ผ ๋‹ค์Œ ์ž‘์—…์„ ์‹œ์ž‘ํ•  ์ˆ˜ ์žˆ์ง€. ์ปคํ”ผ์ˆ์—์„œ ์ฃผ๋ฌธํ•˜๊ณ  ์ปคํ”ผ ๋ฐ›์„ ๋•Œ๊นŒ์ง€ ๊ผผ์ง์—†์ด ๊ธฐ๋‹ค๋ ค์•ผ ํ•˜๋Š” ์ƒํ™ฉ์ด๋ž„๊นŒ?

๋ฐ˜๋ฉด ๋น„๋™๊ธฐ(Asynchronous) ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์ฃผ๋ฌธ๋งŒ ํ•˜๊ณ  ์ง„๋™๋ฒจ ๋ฐ›์•„์„œ ์ž๋ฆฌ๋กœ ๊ฐ€๋Š” ๊ฑฐ์•ผ. โ˜• ์ปคํ”ผ๊ฐ€ ์ค€๋น„๋˜๋ฉด ์•Œ๋ ค์ฃผ๋‹ˆ๊นŒ ๊ทธ๋™์•ˆ ๋‹ค๋ฅธ ์ผ์„ ํ•  ์ˆ˜ ์žˆ์ง€! ์ด๊ฒŒ ๋ฐ”๋กœ ๋น„๋™๊ธฐ์˜ ํ•ต์‹ฌ์ด์•ผ.

๐Ÿ” ์‹ค์ƒํ™œ ๋น„์œ ๋กœ ์ดํ•ดํ•˜๊ธฐ

๋™๊ธฐ ๋ฐฉ์‹:
1. ๋นจ๋ž˜๋ฅผ ๋Œ๋ฆฐ๋‹ค (30๋ถ„ ์†Œ์š”) โ†’ ๋นจ๋ž˜๊ฐ€ ๋๋‚  ๋•Œ๊นŒ์ง€ ์„ธํƒ๊ธฐ ์•ž์—์„œ ๋Œ€๊ธฐ ๐Ÿ˜ด
2. ๋นจ๋ž˜๊ฐ€ ๋๋‚˜๋ฉด ์„ค๊ฑฐ์ง€๋ฅผ ์‹œ์ž‘ (20๋ถ„ ์†Œ์š”) โ†’ ์„ค๊ฑฐ์ง€๊ฐ€ ๋๋‚  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
3. ์„ค๊ฑฐ์ง€๊ฐ€ ๋๋‚˜๋ฉด ์ฒญ์†Œ ์‹œ์ž‘

๋น„๋™๊ธฐ ๋ฐฉ์‹:
1. ๋นจ๋ž˜๋ฅผ ๋Œ๋ฆฐ๋‹ค (30๋ถ„ ์†Œ์š”) โ†’ ๋นจ๋ž˜ ๋Œ์•„๊ฐ€๋Š” ๋™์•ˆ ์„ค๊ฑฐ์ง€ ์‹œ์ž‘ ๐ŸŽ‰
2. ์„ค๊ฑฐ์ง€ํ•˜๋ฉด์„œ ์ฒญ์†Œ๋„ ์กฐ๊ธˆ์”ฉ ์ง„ํ–‰
3. ๋นจ๋ž˜ ๋๋‚˜๋ฉด ์•Œ๋ฆผ ๋ฐ›๊ณ  ๋นจ๋ž˜ ๊บผ๋‚ด๊ธฐ

๊ฐ™์€ ์‹œ๊ฐ„์— ํ›จ์”ฌ ๋งŽ์€ ์ผ์„ ํ•  ์ˆ˜ ์žˆ์ง€? ์ด๊ฒŒ ๋ฐ”๋กœ ๋น„๋™๊ธฐ์˜ ํž˜์ด์•ผ!

๋™๊ธฐ vs ๋น„๋™๊ธฐ ์‹คํ–‰ ํ๋ฆ„ ๋™๊ธฐ ๋ฐฉ์‹ ๋น„๋™๊ธฐ ๋ฐฉ์‹ ์ž‘์—… A (3์ดˆ) ์ž‘์—… B (2์ดˆ) ์ž‘์—… C (2์ดˆ) ์ด ์†Œ์š”์‹œ๊ฐ„: 7์ดˆ ์ž‘์—… A ์ž‘์—… B ์ž‘์—… C ์ด ์†Œ์š”์‹œ๊ฐ„: 3์ดˆ ์ˆœ์ฐจ ์‹คํ–‰ (๋Œ€๊ธฐ ์‹œ๊ฐ„ ๋ฐœ์ƒ) ๋ณ‘๋ ฌ ์‹คํ–‰ (ํšจ์œจ์  ์‹œ๊ฐ„ ํ™œ์šฉ)

โšก async์™€ await์˜ ๋งˆ๋ฒ•

C# 5.0๋ถ€ํ„ฐ ๋“ฑ์žฅํ•œ async์™€ await ํ‚ค์›Œ๋“œ๋Š” ์ •๋ง ํ˜๋ช…์ ์ด์—ˆ์–ด! ์ด์ „์—๋Š” ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด ์ฝœ๋ฐฑ ์ง€์˜ฅ(Callback Hell)์ด๋ผ๊ณ  ๋ถˆ๋ฆด ๋งŒํผ ๋ณต์žกํ–ˆ๊ฑฐ๋“ . ๐Ÿ˜ต

ํ•˜์ง€๋งŒ async/await ๋•๋ถ„์— ๋น„๋™๊ธฐ ์ฝ”๋“œ๋ฅผ ๋งˆ์น˜ ๋™๊ธฐ ์ฝ”๋“œ์ฒ˜๋Ÿผ ์ง๊ด€์ ์œผ๋กœ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ๊ฒŒ ๋์ง€. ์ด๊ฒŒ ์–ผ๋งˆ๋‚˜ ๋Œ€๋‹จํ•œ ๊ฑด์ง€ ์ฝ”๋“œ๋กœ ์ง์ ‘ ๋ณด์—ฌ์ค„๊ฒŒ!

๐Ÿ“ ๊ธฐ๋ณธ ๋ฌธ๋ฒ• ๊ตฌ์กฐ

async/await์˜ ๊ธฐ๋ณธ ๊ตฌ์กฐ๋Š” ์ •๋ง ๊ฐ„๋‹จํ•ด:

// async ํ‚ค์›Œ๋“œ๋กœ ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ์ž„์„ ์„ ์–ธ
public async Task<string> GetDataAsync()
{
    // await ํ‚ค์›Œ๋“œ๋กœ ๋น„๋™๊ธฐ ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
    string result = await SomeAsyncOperation();
    return result;
}

์—ฌ๊ธฐ์„œ ํ•ต์‹ฌ์€:
โœ… async: ์ด ๋ฉ”์„œ๋“œ๊ฐ€ ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ๋ผ๊ณ  ์ปดํŒŒ์ผ๋Ÿฌ์—๊ฒŒ ์•Œ๋ ค์คŒ
โœ… await: ๋น„๋™๊ธฐ ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ฆฌ๋˜, ์Šค๋ ˆ๋“œ๋Š” ๋ธ”๋กœํ‚นํ•˜์ง€ ์•Š์Œ
โœ… Task: ๋น„๋™๊ธฐ ์ž‘์—…์„ ๋‚˜ํƒ€๋‚ด๋Š” ๊ฐ์ฒด (๋ฐ˜ํ™˜๊ฐ’์ด ์žˆ์œผ๋ฉด Task<T>)

๐Ÿ’ก Pro Tip: async ๋ฉ”์„œ๋“œ๋Š” ๋ฐ˜๋“œ์‹œ Task, Task<T>, void ์ค‘ ํ•˜๋‚˜๋ฅผ ๋ฐ˜ํ™˜ํ•ด์•ผ ํ•ด. ํ•˜์ง€๋งŒ void๋Š” ์ด๋ฒคํŠธ ํ•ธ๋“ค๋Ÿฌ์—์„œ๋งŒ ์‚ฌ์šฉํ•˜๋Š” ๊ฒŒ ์ข‹์•„! ์™œ๋ƒํ•˜๋ฉด ์˜ˆ์™ธ ์ฒ˜๋ฆฌ๊ฐ€ ์–ด๋ ต๊ณ  ์ž‘์—… ์™„๋ฃŒ๋ฅผ ์ถ”์ ํ•  ์ˆ˜ ์—†๊ฑฐ๋“ .

๐ŸŽฌ ์‹ค์ „ ์˜ˆ์ œ: ์›น ๋ฐ์ดํ„ฐ ๊ฐ€์ ธ์˜ค๊ธฐ

์‹ค์ œ๋กœ ๋งŽ์ด ์‚ฌ์šฉํ•˜๋Š” ์‹œ๋‚˜๋ฆฌ์˜ค๋ฅผ ๋ณด์ž. ์›น API์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ๊ฒฝ์šฐ์•ผ:

using System;
using System.Net.Http;
using System.Threading.Tasks;

public class DataService
{
    private static readonly HttpClient client = new HttpClient();
    
    // ๋™๊ธฐ ๋ฐฉ์‹ (๋‚˜์œ ์˜ˆ์‹œ โŒ)
    public string GetDataSync(string url)
    {
        // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด UI๊ฐ€ ๋ฉˆ์ถฐ๋ฒ„๋ ค!
        var response = client.GetStringAsync(url).Result;
        return response;
    }
    
    // ๋น„๋™๊ธฐ ๋ฐฉ์‹ (์ข‹์€ ์˜ˆ์‹œ โœ…)
    public async Task<string> GetDataAsync(string url)
    {
        try
        {
            // await๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด UI๋Š” ๊ณ„์† ๋ฐ˜์‘ํ•ด!
            string response = await client.GetStringAsync(url);
            
            // ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ
            string processed = ProcessData(response);
            
            return processed;
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"์˜ค๋ฅ˜ ๋ฐœ์ƒ: {ex.Message}");
            return null;
        }
    }
    
    private string ProcessData(string data)
    {
        // ๋ฐ์ดํ„ฐ ๊ฐ€๊ณต ๋กœ์ง
        return data.ToUpper();
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public async Task UseDataService()
{
    var service = new DataService();
    
    // ์—ฌ๋Ÿฌ ์š”์ฒญ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด!
    var task1 = service.GetDataAsync("https://api.example.com/data1");
    var task2 = service.GetDataAsync("https://api.example.com/data2");
    var task3 = service.GetDataAsync("https://api.example.com/data3");
    
    // ๋ชจ๋“  ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
    await Task.WhenAll(task1, task2, task3);
    
    Console.WriteLine($"๊ฒฐ๊ณผ1: {task1.Result}");
    Console.WriteLine($"๊ฒฐ๊ณผ2: {task2.Result}");
    Console.WriteLine($"๊ฒฐ๊ณผ3: {task3.Result}");
}

์œ„ ์ฝ”๋“œ์—์„œ ์ฃผ๋ชฉํ•  ์ ์€ Task.WhenAll์ด์•ผ! ์ด๊ฑธ ์‚ฌ์šฉํ•˜๋ฉด ์—ฌ๋Ÿฌ ๋น„๋™๊ธฐ ์ž‘์—…์„ ๋™์‹œ์— ์‹คํ–‰ํ•˜๊ณ , ๋ชจ๋‘ ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๊ธฐ๋‹ค๋ฆด ์ˆ˜ ์žˆ์–ด. ์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰ํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ํ›จ์”ฌ ๋น ๋ฅด์ง€! ๐Ÿš€

๐ŸŽญ Task์˜ ๋ชจ๋“  ๊ฒƒ

Task๋Š” ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ•ต์‹ฌ ํด๋ž˜์Šค์•ผ. .NET Framework 4.0๋ถ€ํ„ฐ ๋„์ž…๋œ Task๋Š” ๋น„๋™๊ธฐ ์ž‘์—…์„ ํ‘œํ˜„ํ•˜๋Š” ๊ฐ์ฒด๋กœ, ์ž‘์—…์˜ ์ƒํƒœ, ๊ฒฐ๊ณผ, ์˜ˆ์™ธ ๋“ฑ์„ ๊ด€๋ฆฌํ•ด์ค˜.

Task๋ฅผ ์ œ๋Œ€๋กœ ์ดํ•ดํ•˜๋ฉด ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ 90%๋Š” ๋งˆ์Šคํ„ฐํ•œ ๊ฑฐ๋‚˜ ๋‹ค๋ฆ„์—†์–ด! ๐Ÿ’ช

๐Ÿ”ง Task์˜ ์ฃผ์š” ํŠน์ง•

ํŠน์ง• ์„ค๋ช… ์˜ˆ์‹œ
Task ๋ฐ˜ํ™˜๊ฐ’์ด ์—†๋Š” ๋น„๋™๊ธฐ ์ž‘์—… Task.Run(() => DoWork())
Task<T> T ํƒ€์ž…์˜ ๊ฒฐ๊ณผ๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋Š” ๋น„๋™๊ธฐ ์ž‘์—… Task<int> GetNumberAsync()
Task.Status ์ž‘์—…์˜ ํ˜„์žฌ ์ƒํƒœ (Created, Running, Completed ๋“ฑ) if (task.Status == TaskStatus.Running)
Task.Result ์ž‘์—…์˜ ๊ฒฐ๊ณผ๊ฐ’ (๋ธ”๋กœํ‚น ๋ฐœ์ƒ ์ฃผ์˜!) int result = task.Result;
Task.Exception ์ž‘์—… ์ค‘ ๋ฐœ์ƒํ•œ ์˜ˆ์™ธ if (task.Exception != null)

๐ŸŽจ Task ์ƒ์„ฑ ๋ฐฉ๋ฒ•๋“ค

Task๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐฉ๋ฒ•์€ ์—ฌ๋Ÿฌ ๊ฐ€์ง€๊ฐ€ ์žˆ์–ด. ์ƒํ™ฉ์— ๋งž๊ฒŒ ์„ ํƒํ•˜๋ฉด ๋ผ:

// 1. Task.Run - CPU ์ง‘์•ฝ์  ์ž‘์—…์— ์ ํ•ฉ
Task<int> task1 = Task.Run(() => 
{
    // ๋ณต์žกํ•œ ๊ณ„์‚ฐ ์ž‘์—…
    int sum = 0;
    for (int i = 0; i < 1000000; i++)
    {
        sum += i;
    }
    return sum;
});

// 2. Task.Factory.StartNew - ๋” ์„ธ๋ฐ€ํ•œ ์ œ์–ด๊ฐ€ ํ•„์š”ํ•  ๋•Œ
Task<int> task2 = Task.Factory.StartNew(() => 
{
    return 42;
}, TaskCreationOptions.LongRunning); // ์žฅ์‹œ๊ฐ„ ์‹คํ–‰๋˜๋Š” ์ž‘์—…์ž„์„ ๋ช…์‹œ

// 3. async ๋ฉ”์„œ๋“œ - ๊ฐ€์žฅ ๊ถŒ์žฅ๋˜๋Š” ๋ฐฉ์‹
public async Task<int> CalculateAsync()
{
    await Task.Delay(1000); // 1์ดˆ ๋Œ€๊ธฐ
    return 100;
}

// 4. Task.FromResult - ์ด๋ฏธ ๊ฒฐ๊ณผ๊ฐ€ ์žˆ์„ ๋•Œ
Task<int> task3 = Task.FromResult(42);

// 5. TaskCompletionSource - ์ˆ˜๋™์œผ๋กœ Task ์ œ์–ด
var tcs = new TaskCompletionSource<int>();
Task<int> task4 = tcs.Task;
// ๋‚˜์ค‘์— ๊ฒฐ๊ณผ ์„ค์ •
tcs.SetResult(100);
โš ๏ธ ์ฃผ์˜์‚ฌํ•ญ: Task.Result๋‚˜ Task.Wait()๋Š” ์Šค๋ ˆ๋“œ๋ฅผ ๋ธ”๋กœํ‚น์‹œ์ผœ! async/await ์ปจํ…์ŠคํŠธ์—์„œ๋Š” ์ ˆ๋Œ€ ์‚ฌ์šฉํ•˜์ง€ ๋ง๊ณ , ๋Œ€์‹  await๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ด. ๋ฐ๋“œ๋ฝ(Deadlock)์˜ ์ฃผ๋ฒ”์ด๊ฑฐ๋“ ! ๐Ÿ˜ฑ

๐ŸŽฏ Task ์กฐํ•ฉ ๋ฉ”์„œ๋“œ๋“ค

์—ฌ๋Ÿฌ Task๋ฅผ ์กฐํ•ฉํ•ด์„œ ์‚ฌ์šฉํ•˜๋Š” ๊ฐ•๋ ฅํ•œ ๋ฉ”์„œ๋“œ๋“ค์ด ์žˆ์–ด:

public async Task DemoTaskCombinations()
{
    // Task.WhenAll - ๋ชจ๋“  ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
    var tasks = new[]
    {
        DownloadAsync("url1"),
        DownloadAsync("url2"),
        DownloadAsync("url3")
    };
    
    string[] results = await Task.WhenAll(tasks);
    Console.WriteLine($"๋ชจ๋“  ๋‹ค์šด๋กœ๋“œ ์™„๋ฃŒ! ์ด {results.Length}๊ฐœ");
    
    // Task.WhenAny - ํ•˜๋‚˜๋ผ๋„ ์™„๋ฃŒ๋˜๋ฉด ์ง„ํ–‰
    Task<string> firstCompleted = await Task.WhenAny(tasks);
    Console.WriteLine($"๊ฐ€์žฅ ๋น ๋ฅธ ๊ฒฐ๊ณผ: {await firstCompleted}");
    
    // Task.Delay - ๋น„๋™๊ธฐ ๋Œ€๊ธฐ (Thread.Sleep๋ณด๋‹ค ํ›จ์”ฌ ์ข‹์•„!)
    await Task.Delay(TimeSpan.FromSeconds(2));
    Console.WriteLine("2์ดˆ ๊ฒฝ๊ณผ!");
    
    // Task.FromException - ์˜ˆ์™ธ๋ฅผ ํฌํ•จํ•œ Task ์ƒ์„ฑ
    Task<int> faultyTask = Task.FromException<int>(
        new InvalidOperationException("์˜๋„์  ์˜ค๋ฅ˜")
    );
    
    // Task.FromCanceled - ์ทจ์†Œ๋œ Task ์ƒ์„ฑ
    var cts = new CancellationTokenSource();
    cts.Cancel();
    Task canceledTask = Task.FromCanceled(cts.Token);
}

private async Task<string> DownloadAsync(string url)
{
    await Task.Delay(Random.Shared.Next(1000, 3000));
    return $"Downloaded from {url}";
}
Task ์ƒ๋ช…์ฃผ๊ธฐ์™€ ์ƒํƒœ ์ „ํ™˜ Created Running Ran To Completion Faulted Canceled Start Success Exception Cancel ์ƒํƒœ๋ณ„ ์„ค๋ช… Created: Task ๊ฐ์ฒด๊ฐ€ ์ƒ์„ฑ๋˜์—ˆ์ง€๋งŒ ์•„์ง ์‹œ์ž‘๋˜์ง€ ์•Š์Œ Running: Task๊ฐ€ ํ˜„์žฌ ์‹คํ–‰ ์ค‘ RanToCompletion: Task๊ฐ€ ์„ฑ๊ณต์ ์œผ๋กœ ์™„๋ฃŒ๋จ Faulted: ์‹คํ–‰ ์ค‘ ์˜ˆ์™ธ๊ฐ€ ๋ฐœ์ƒํ•จ Canceled: Task๊ฐ€ ์ทจ์†Œ๋จ

๐ŸŽช ์‹ค์ „ ํŒจํ„ด๊ณผ ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

์ด๋ก ์€ ์ถฉ๋ถ„ํžˆ ๋ฐฐ์› ์œผ๋‹ˆ ์ด์ œ ์‹ค์ „์—์„œ ์–ด๋–ป๊ฒŒ ํ™œ์šฉํ•˜๋Š”์ง€ ์•Œ์•„๋ณด์ž! ์‹ค๋ฌด์—์„œ ์ž์ฃผ ๋งˆ์ฃผ์น˜๋Š” ์‹œ๋‚˜๋ฆฌ์˜ค๋“ค๊ณผ ํ•ด๊ฒฐ ๋ฐฉ๋ฒ•์„ ์†Œ๊ฐœํ• ๊ฒŒ. ๐Ÿ˜Ž

๐ŸŽฏ ํŒจํ„ด 1: ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋กœ ์„ฑ๋Šฅ ๊ทน๋Œ€ํ™”

์—ฌ๋Ÿฌ ๋…๋ฆฝ์ ์ธ ์ž‘์—…์„ ๋™์‹œ์— ์ฒ˜๋ฆฌํ•˜๋ฉด ์—„์ฒญ๋‚œ ์„ฑ๋Šฅ ํ–ฅ์ƒ์„ ์–ป์„ ์ˆ˜ ์žˆ์–ด:

public class ParallelProcessingExample
{
    // ๋‚˜์œ ์˜ˆ: ์ˆœ์ฐจ ์ฒ˜๋ฆฌ (๋А๋ฆผ ๐ŸŒ)
    public async Task<List<UserData>> GetUserDataSequential(List<int> userIds)
    {
        var results = new List<UserData>();
        
        foreach (var userId in userIds)
        {
            var userData = await FetchUserDataAsync(userId); // ํ•˜๋‚˜์”ฉ ๋Œ€๊ธฐ
            results.Add(userData);
        }
        
        return results; // 10๋ช…์ด๋ฉด 10์ดˆ ๊ฑธ๋ฆผ
    }
    
    // ์ข‹์€ ์˜ˆ: ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ (๋น ๋ฆ„ ๐Ÿš€)
    public async Task<List<UserData>> GetUserDataParallel(List<int> userIds)
    {
        // ๋ชจ๋“  ์š”์ฒญ์„ ๋™์‹œ์— ์‹œ์ž‘
        var tasks = userIds.Select(id => FetchUserDataAsync(id));
        
        // ๋ชจ๋“  ์ž‘์—…์ด ์™„๋ฃŒ๋  ๋•Œ๊นŒ์ง€ ๋Œ€๊ธฐ
        var results = await Task.WhenAll(tasks);
        
        return results.ToList(); // 10๋ช…์ด์–ด๋„ 1~2์ดˆ๋ฉด ๋!
    }
    
    // ๋” ๋‚˜์€ ์˜ˆ: ๋™์‹œ ์‹คํ–‰ ์ˆ˜ ์ œํ•œ (์„œ๋ฒ„ ๋ถ€ํ•˜ ๊ณ ๋ ค)
    public async Task<List<UserData>> GetUserDataThrottled(
        List<int> userIds, 
        int maxConcurrency = 5)
    {
        var results = new List<UserData>();
        var semaphore = new SemaphoreSlim(maxConcurrency);
        
        var tasks = userIds.Select(async userId =>
        {
            await semaphore.WaitAsync(); // ๋™์‹œ ์‹คํ–‰ ์ˆ˜ ์ œํ•œ
            try
            {
                return await FetchUserDataAsync(userId);
            }
            finally
            {
                semaphore.Release();
            }
        });
        
        return (await Task.WhenAll(tasks)).ToList();
    }
    
    private async Task<UserData> FetchUserDataAsync(int userId)
    {
        await Task.Delay(1000); // API ํ˜ธ์ถœ ์‹œ๋ฎฌ๋ ˆ์ด์…˜
        return new UserData { Id = userId, Name = $"User{userId}" };
    }
}

public class UserData
{
    public int Id { get; set; }
    public string Name { get; set; }
}
๐Ÿ’ก ์„ฑ๋Šฅ ํŒ: ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ๋Š” ๊ฐ•๋ ฅํ•˜์ง€๋งŒ ๋ฌด๋ถ„๋ณ„ํ•˜๊ฒŒ ์‚ฌ์šฉํ•˜๋ฉด ์•ˆ ๋ผ! ์„œ๋ฒ„์— ๋™์‹œ์— 1000๊ฐœ์˜ ์š”์ฒญ์„ ๋ณด๋‚ด๋ฉด ์˜คํžˆ๋ ค ์„ฑ๋Šฅ์ด ๋–จ์–ด์ง€๊ฑฐ๋‚˜ ์„œ๋ฒ„๊ฐ€ ์ฐจ๋‹จํ•  ์ˆ˜ ์žˆ์–ด. SemaphoreSlim์œผ๋กœ ๋™์‹œ ์‹คํ–‰ ์ˆ˜๋ฅผ ์ œํ•œํ•˜๋Š” ๊ฒŒ ํ˜„๋ช…ํ•ด! ๐Ÿง 

๐ŸŽฏ ํŒจํ„ด 2: ์ทจ์†Œ ํ† ํฐ์œผ๋กœ ์ž‘์—… ์ œ์–ดํ•˜๊ธฐ

์‚ฌ์šฉ์ž๊ฐ€ ์ž‘์—…์„ ์ทจ์†Œํ•˜๊ณ  ์‹ถ์„ ๋•Œ๊ฐ€ ์žˆ์ง€? ์˜ˆ๋ฅผ ๋“ค์–ด ํŒŒ์ผ ๋‹ค์šด๋กœ๋“œ ์ค‘์— "์ทจ์†Œ" ๋ฒ„ํŠผ์„ ๋ˆ„๋ฅด๋Š” ๊ฒฝ์šฐ! ์ด๋Ÿด ๋•Œ CancellationToken์„ ์‚ฌ์šฉํ•ด:

public class CancellationExample
{
    // ์ทจ์†Œ ๊ฐ€๋Šฅํ•œ ๋‹ค์šด๋กœ๋“œ ๋ฉ”์„œ๋“œ
    public async Task<byte[]> DownloadFileAsync(
        string url, 
        CancellationToken cancellationToken)
    {
        using var client = new HttpClient();
        
        try
        {
            // ์ทจ์†Œ ํ† ํฐ์„ ์ „๋‹ฌ
            var response = await client.GetAsync(url, cancellationToken);
            
            // ์ค‘๊ฐ„์— ์ทจ์†Œ ํ™•์ธ
            cancellationToken.ThrowIfCancellationRequested();
            
            return await response.Content.ReadAsByteArrayAsync();
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("๋‹ค์šด๋กœ๋“œ๊ฐ€ ์ทจ์†Œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค.");
            throw; // ์ƒ์œ„๋กœ ์ „ํŒŒ
        }
    }
    
    // ํƒ€์ž„์•„์›ƒ์ด ์žˆ๋Š” ์ž‘์—…
    public async Task<string> GetDataWithTimeout(string url, int timeoutSeconds)
    {
        using var cts = new CancellationTokenSource();
        cts.CancelAfter(TimeSpan.FromSeconds(timeoutSeconds));
        
        try
        {
            return await DownloadFileAsync(url, cts.Token);
        }
        catch (OperationCanceledException)
        {
            throw new TimeoutException($"{timeoutSeconds}์ดˆ ๋‚ด์— ์™„๋ฃŒ๋˜์ง€ ์•Š์•˜์Šต๋‹ˆ๋‹ค.");
        }
    }
    
    // ์‚ฌ์šฉ ์˜ˆ์‹œ
    public async Task UseExample()
    {
        var cts = new CancellationTokenSource();
        
        // 5์ดˆ ํ›„ ์ž๋™ ์ทจ์†Œ
        cts.CancelAfter(TimeSpan.FromSeconds(5));
        
        // ๋˜๋Š” ๋ฒ„ํŠผ ํด๋ฆญ ์‹œ ์ทจ์†Œ
        // cancelButton.Click += (s, e) => cts.Cancel();
        
        try
        {
            var data = await DownloadFileAsync(
                "https://example.com/largefile.zip", 
                cts.Token
            );
            Console.WriteLine($"๋‹ค์šด๋กœ๋“œ ์™„๋ฃŒ: {data.Length} bytes");
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("์‚ฌ์šฉ์ž๊ฐ€ ์ทจ์†Œํ–ˆ๊ฑฐ๋‚˜ ํƒ€์ž„์•„์›ƒ ๋ฐœ์ƒ!");
        }
    }
}

๐ŸŽฏ ํŒจํ„ด 3: ์˜ˆ์™ธ ์ฒ˜๋ฆฌ ์ „๋žต

๋น„๋™๊ธฐ ์ฝ”๋“œ์—์„œ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ๋Š” ํŠน๋ณ„ํžˆ ์‹ ๊ฒฝ ์จ์•ผ ํ•ด! ์ž˜๋ชปํ•˜๋ฉด ์˜ˆ์™ธ๊ฐ€ ์กฐ์šฉํžˆ ์‚ฌ๋ผ์งˆ ์ˆ˜ ์žˆ๊ฑฐ๋“ :

public class ExceptionHandlingExample
{
    // ๊ธฐ๋ณธ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
    public async Task<string> SafeApiCall(string url)
    {
        try
        {
            using var client = new HttpClient();
            return await client.GetStringAsync(url);
        }
        catch (HttpRequestException ex)
        {
            // ๋„คํŠธ์›Œํฌ ์˜ค๋ฅ˜
            Console.WriteLine($"๋„คํŠธ์›Œํฌ ์˜ค๋ฅ˜: {ex.Message}");
            return null;
        }
        catch (TaskCanceledException ex)
        {
            // ํƒ€์ž„์•„์›ƒ
            Console.WriteLine($"์š”์ฒญ ์‹œ๊ฐ„ ์ดˆ๊ณผ: {ex.Message}");
            return null;
        }
        catch (Exception ex)
        {
            // ๊ธฐํƒ€ ์˜ˆ์™ธ
            Console.WriteLine($"์˜ˆ์ƒ์น˜ ๋ชปํ•œ ์˜ค๋ฅ˜: {ex.Message}");
            throw; // ์‹ฌ๊ฐํ•œ ์˜ค๋ฅ˜๋Š” ์ƒ์œ„๋กœ ์ „ํŒŒ
        }
    }
    
    // ์—ฌ๋Ÿฌ ์ž‘์—…์˜ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
    public async Task<List<string>> MultipleApiCallsWithErrorHandling(
        List<string> urls)
    {
        var tasks = urls.Select(async url =>
        {
            try
            {
                return await SafeApiCall(url);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"{url} ์‹คํŒจ: {ex.Message}");
                return null; // ์‹คํŒจํ•œ ๊ฒƒ๋งŒ null๋กœ ๋ฐ˜ํ™˜
            }
        });
        
        var results = await Task.WhenAll(tasks);
        
        // null์ด ์•„๋‹Œ ๊ฒƒ๋งŒ ๋ฐ˜ํ™˜
        return results.Where(r => r != null).ToList();
    }
    
    // AggregateException ์ฒ˜๋ฆฌ
    public async Task HandleAggregateException()
    {
        var tasks = new[]
        {
            Task.Run(() => throw new InvalidOperationException("์˜ค๋ฅ˜1")),
            Task.Run(() => throw new ArgumentException("์˜ค๋ฅ˜2")),
            Task.Run(() => throw new NullReferenceException("์˜ค๋ฅ˜3"))
        };
        
        try
        {
            await Task.WhenAll(tasks);
        }
        catch (Exception ex)
        {
            // Task.WhenAll์€ ์ฒซ ๋ฒˆ์งธ ์˜ˆ์™ธ๋งŒ ๋˜์ง
            Console.WriteLine($"์ฒซ ๋ฒˆ์งธ ์˜ˆ์™ธ: {ex.Message}");
            
            // ๋ชจ๋“  ์˜ˆ์™ธ๋ฅผ ํ™•์ธํ•˜๋ ค๋ฉด
            foreach (var task in tasks)
            {
                if (task.Exception != null)
                {
                    foreach (var innerEx in task.Exception.InnerExceptions)
                    {
                        Console.WriteLine($"์˜ˆ์™ธ ๋ฐœ๊ฒฌ: {innerEx.Message}");
                    }
                }
            }
        }
    }
}
โš ๏ธ ํ”ํ•œ ์‹ค์ˆ˜: async void ๋ฉ”์„œ๋“œ์—์„œ ๋ฐœ์ƒํ•œ ์˜ˆ์™ธ๋Š” catchํ•  ์ˆ˜ ์—†์–ด! ์•ฑ์ด ํฌ๋ž˜์‹œ๋  ์ˆ˜ ์žˆ์œผ๋‹ˆ ์ ˆ๋Œ€ async void๋Š” ์ด๋ฒคํŠธ ํ•ธ๋“ค๋Ÿฌ ์™ธ์—๋Š” ์‚ฌ์šฉํ•˜์ง€ ๋งˆ! ๋Œ€์‹  async Task๋ฅผ ์‚ฌ์šฉํ•ด์•ผ ํ•ด.

๐Ÿ—๏ธ ๊ณ ๊ธ‰ ํŒจํ„ด๊ณผ ์ตœ์ ํ™” ๊ธฐ๋ฒ•

์ด์ œ ์ข€ ๋” ๊ณ ๊ธ‰ ๊ธฐ๋ฒ•๋“ค์„ ์•Œ์•„๋ณด์ž! ์ด๋Ÿฐ ํŒจํ„ด๋“ค์„ ์•Œ๋ฉด ์ง„์งœ ํ”„๋กœ ๊ฐœ๋ฐœ์ž์ฒ˜๋Ÿผ ์ฝ”๋“œ๋ฅผ ์ž‘์„ฑํ•  ์ˆ˜ ์žˆ์–ด. ๐ŸŽ“

๐ŸŽฏ ValueTask๋กœ ์„ฑ๋Šฅ ์ตœ์ ํ™”

ValueTask<T>๋Š” Task<T>๋ณด๋‹ค ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ์ด์•ผ. ํŠนํžˆ ๊ฒฐ๊ณผ๊ฐ€ ์ด๋ฏธ ์ค€๋น„๋˜์–ด ์žˆ๊ฑฐ๋‚˜ ๋™๊ธฐ์ ์œผ๋กœ ์™„๋ฃŒ๋˜๋Š” ๊ฒฝ์šฐ์— ์œ ์šฉํ•ด:

public class ValueTaskExample
{
    private Dictionary<string, string> _cache = new();
    
    // Task ๋ฒ„์ „ - ํ•ญ์ƒ ํž™ ํ• ๋‹น ๋ฐœ์ƒ
    public async Task<string> GetDataWithTask(string key)
    {
        if (_cache.TryGetValue(key, out var cached))
        {
            return cached; // ์บ์‹œ ํžˆํŠธ์—ฌ๋„ Task ๊ฐ์ฒด ์ƒ์„ฑ
        }
        
        var data = await FetchFromDatabaseAsync(key);
        _cache[key] = data;
        return data;
    }
    
    // ValueTask ๋ฒ„์ „ - ์บ์‹œ ํžˆํŠธ ์‹œ ํ• ๋‹น ์—†์Œ! ๐ŸŽ‰
    public async ValueTask<string> GetDataWithValueTask(string key)
    {
        if (_cache.TryGetValue(key, out var cached))
        {
            return cached; // ํž™ ํ• ๋‹น ์—†์ด ๋ฐ”๋กœ ๋ฐ˜ํ™˜!
        }
        
        var data = await FetchFromDatabaseAsync(key);
        _cache[key] = data;
        return data;
    }
    
    private async Task<string> FetchFromDatabaseAsync(string key)
    {
        await Task.Delay(100); // DB ์กฐํšŒ ์‹œ๋ฎฌ๋ ˆ์ด์…˜
        return $"Data for {key}";
    }
}

// ์„ฑ๋Šฅ ๋น„๊ต
public class PerformanceComparison
{
    public async Task ComparePerformance()
    {
        var example = new ValueTaskExample();
        
        // ์ฒซ ํ˜ธ์ถœ - ๋‘˜ ๋‹ค ๋น„์Šท
        await example.GetDataWithTask("key1");
        await example.GetDataWithValueTask("key1");
        
        // ์บ์‹œ๋œ ๋ฐ์ดํ„ฐ ๋ฐ˜๋ณต ํ˜ธ์ถœ - ValueTask๊ฐ€ ํ›จ์”ฌ ๋น ๋ฆ„!
        for (int i = 0; i < 1000000; i++)
        {
            await example.GetDataWithValueTask("key1"); // ๋ฉ”๋ชจ๋ฆฌ ํ• ๋‹น ๊ฑฐ์˜ ์—†์Œ
        }
    }
}
๐Ÿ’ก ์–ธ์ œ ValueTask๋ฅผ ์‚ฌ์šฉํ• ๊นŒ? โœ… ์บ์‹ฑ์ด ๋งŽ์ด ์‚ฌ์šฉ๋˜๋Š” ๊ฒฝ์šฐ
โœ… ๋™๊ธฐ์ ์œผ๋กœ ์™„๋ฃŒ๋˜๋Š” ๊ฒฝ์šฐ๊ฐ€ ๋งŽ์€ ๊ฒฝ์šฐ
โœ… ๊ณ ์„ฑ๋Šฅ์ด ์ค‘์š”ํ•œ ํ•ซํŒจ์Šค(hot path)
โŒ ์—ฌ๋Ÿฌ ๋ฒˆ awaitํ•˜๋Š” ๊ฒฝ์šฐ (ValueTask๋Š” ํ•œ ๋ฒˆ๋งŒ await ๊ฐ€๋Šฅ!)
โŒ ๊ฒฐ๊ณผ๋ฅผ ์ €์žฅํ•ด์•ผ ํ•˜๋Š” ๊ฒฝ์šฐ

๐ŸŽฏ ConfigureAwait๋กœ ์ปจํ…์ŠคํŠธ ์ œ์–ด

ConfigureAwait(false)๋Š” ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์ฝ”๋“œ์—์„œ ์„ฑ๋Šฅ์„ ๋†’์ด๋Š” ๋น„๋ฐ€ ๋ฌด๊ธฐ์•ผ:

public class ConfigureAwaitExample
{
    // UI ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์—์„œ (WPF, WinForms, etc.)
    public async Task UpdateUIAsync()
    {
        var data = await GetDataAsync(); // UI ์Šค๋ ˆ๋“œ๋กœ ๋Œ์•„์˜ด
        
        // UI ์—…๋ฐ์ดํŠธ ๊ฐ€๋Šฅ
        // textBox.Text = data; 
    }
    
    // ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์ฝ”๋“œ - ConfigureAwait(false) ์‚ฌ์šฉ
    public async Task<string> GetDataAsync()
    {
        using var client = new HttpClient();
        
        // ConfigureAwait(false) - UI ์Šค๋ ˆ๋“œ๋กœ ๋Œ์•„๊ฐˆ ํ•„์š” ์—†์Œ
        var response = await client.GetStringAsync("https://api.example.com")
            .ConfigureAwait(false);
        
        // ์—ฌ๊ธฐ์„œ๋Š” UI ์ ‘๊ทผ ๋ถˆ๊ฐ€! (ํ•˜์ง€๋งŒ ๋” ๋น ๋ฆ„)
        var processed = ProcessData(response);
        
        return processed;
    }
    
    private string ProcessData(string data)
    {
        // ์ˆœ์ˆ˜ ๊ณ„์‚ฐ ๋กœ์ง
        return data.ToUpper();
    }
}

// ์‹ค์ „ ์˜ˆ์‹œ: ASP.NET Core์—์„œ
public class ApiController
{
    private readonly HttpClient _httpClient;
    
    public async Task<IActionResult> GetUserData(int userId)
    {
        // ASP.NET Core๋Š” SynchronizationContext๊ฐ€ ์—†์œผ๋ฏ€๋กœ
        // ConfigureAwait(false)๊ฐ€ ํฐ ์˜๋ฏธ๋Š” ์—†์ง€๋งŒ
        // ์Šต๊ด€์ ์œผ๋กœ ์‚ฌ์šฉํ•˜๋ฉด ์ข‹์Œ
        var userData = await FetchUserAsync(userId)
            .ConfigureAwait(false);
        
        return Ok(userData);
    }
    
    private async Task<User> FetchUserAsync(int userId)
    {
        var response = await _httpClient
            .GetStringAsync($"https://api.example.com/users/{userId}")
            .ConfigureAwait(false);
        
        return JsonSerializer.Deserialize<User>(response);
    }
}

๐ŸŽฏ IAsyncEnumerable๋กœ ์ŠคํŠธ๋ฆฌ๋ฐ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ

C# 8.0๋ถ€ํ„ฐ ๋„์ž…๋œ IAsyncEnumerable<T>๋Š” ๋น„๋™๊ธฐ ์ŠคํŠธ๋ฆผ์„ ์ฒ˜๋ฆฌํ•  ๋•Œ ์ •๋ง ์œ ์šฉํ•ด:

public class AsyncEnumerableExample
{
    // ์ „ํ†ต์ ์ธ ๋ฐฉ์‹ - ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋ฅผ ๋ฉ”๋ชจ๋ฆฌ์— ๋กœ๋“œ
    public async Task<List<string>> GetAllLogsOldWay()
    {
        var logs = new List<string>();
        
        for (int i = 0; i < 10000; i++)
        {
            var log = await FetchLogAsync(i);
            logs.Add(log);
        }
        
        return logs; // ๋ฉ”๋ชจ๋ฆฌ ๋งŽ์ด ์‚ฌ์šฉ! ๐Ÿ˜ฐ
    }
    
    // ์ƒˆ๋กœ์šด ๋ฐฉ์‹ - ์ŠคํŠธ๋ฆฌ๋ฐ์œผ๋กœ ์ฒ˜๋ฆฌ
    public async IAsyncEnumerable<string> GetAllLogsNewWay()
    {
        for (int i = 0; i < 10000; i++)
        {
            var log = await FetchLogAsync(i);
            yield return log; // ํ•˜๋‚˜์”ฉ ๋ฐ˜ํ™˜! ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์ ! ๐ŸŽ‰
        }
    }
    
    // ์‚ฌ์šฉ ์˜ˆ์‹œ
    public async Task ProcessLogs()
    {
        await foreach (var log in GetAllLogsNewWay())
        {
            // ๋กœ๊ทธ๋ฅผ ํ•˜๋‚˜์”ฉ ์ฒ˜๋ฆฌ
            Console.WriteLine(log);
            
            // ํ•„์š”ํ•˜๋ฉด ์ค‘๊ฐ„์— ์ค‘๋‹จ ๊ฐ€๋Šฅ
            if (log.Contains("ERROR"))
            {
                break;
            }
        }
    }
    
    // ์‹ค์ „ ์˜ˆ์‹œ: ๋Œ€์šฉ๋Ÿ‰ ํŒŒ์ผ ์ฝ๊ธฐ
    public async IAsyncEnumerable<string> ReadLargeFileAsync(
        string filePath,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        using var reader = new StreamReader(filePath);
        
        while (!reader.EndOfStream)
        {
            cancellationToken.ThrowIfCancellationRequested();
            
            var line = await reader.ReadLineAsync();
            if (line != null)
            {
                yield return line;
            }
        }
    }
    
    // LINQ์™€ ํ•จ๊ป˜ ์‚ฌ์šฉ
    public async Task UseWithLinq()
    {
        var errorLogs = GetAllLogsNewWay()
            .Where(log => log.Contains("ERROR"))
            .Take(10);
        
        await foreach (var log in errorLogs)
        {
            Console.WriteLine(log);
        }
    }
    
    private async Task<string> FetchLogAsync(int index)
    {
        await Task.Delay(10);
        return $"Log entry {index}";
    }
}

๐Ÿ“Š IAsyncEnumerable์˜ ์žฅ์ 

1. ๋ฉ”๋ชจ๋ฆฌ ํšจ์œจ์„ฑ ๐Ÿ’พ
์ „์ฒด ๋ฐ์ดํ„ฐ๋ฅผ ๋ฉ”๋ชจ๋ฆฌ์— ๋กœ๋“œํ•˜์ง€ ์•Š๊ณ  ํ•„์š”ํ•œ ๋งŒํผ๋งŒ ์ฒ˜๋ฆฌ

2. ์‘๋‹ต์„ฑ ํ–ฅ์ƒ โšก
์ฒซ ๋ฒˆ์งธ ํ•ญ๋ชฉ์„ ์ฆ‰์‹œ ์ฒ˜๋ฆฌํ•  ์ˆ˜ ์žˆ์–ด ์‚ฌ์šฉ์ž ๊ฒฝํ—˜ ๊ฐœ์„ 

3. ์ทจ์†Œ ์ง€์› ๐Ÿ›‘
CancellationToken์œผ๋กœ ์–ธ์ œ๋“  ์ค‘๋‹จ ๊ฐ€๋Šฅ

4. ๋ฌดํ•œ ์ŠคํŠธ๋ฆผ ์ง€์› โ™พ๏ธ
๋์ด ์—†๋Š” ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆผ๋„ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ (์˜ˆ: ์‹ค์‹œ๊ฐ„ ์„ผ์„œ ๋ฐ์ดํ„ฐ)

๐ŸŽฎ ์‹ค์ „ ํ”„๋กœ์ ํŠธ ์˜ˆ์ œ

์ด๋ก ๋งŒ ๋ฐฐ์šฐ๋ฉด ์žฌ๋ฏธ์—†์ง€! ์‹ค์ œ๋กœ ๋™์ž‘ํ•˜๋Š” ์™„์ „ํ•œ ์˜ˆ์ œ๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž. ์—ฌ๊ธฐ์„œ๋Š” ๋‚ ์”จ ์ •๋ณด๋ฅผ ๊ฐ€์ ธ์˜ค๋Š” ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์„ ๋งŒ๋“ค ๊ฑฐ์•ผ. ๐ŸŒค๏ธ

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;

// ๋‚ ์”จ ๋ฐ์ดํ„ฐ ๋ชจ๋ธ
public class WeatherData
{
    public string City { get; set; }
    public double Temperature { get; set; }
    public string Description { get; set; }
    public DateTime Timestamp { get; set; }
}

// ๋‚ ์”จ ์„œ๋น„์Šค ์ธํ„ฐํŽ˜์ด์Šค
public interface IWeatherService
{
    Task<WeatherData> GetWeatherAsync(string city, CancellationToken ct = default);
    Task<List<WeatherData>> GetMultipleCitiesWeatherAsync(
        List<string> cities, 
        CancellationToken ct = default);
    IAsyncEnumerable<WeatherData> StreamWeatherUpdatesAsync(
        string city, 
        TimeSpan interval,
        CancellationToken ct = default);
}

// ๋‚ ์”จ ์„œ๋น„์Šค ๊ตฌํ˜„
public class WeatherService : IWeatherService
{
    private readonly HttpClient _httpClient;
    private readonly Dictionary<string, WeatherData> _cache;
    private readonly SemaphoreSlim _cacheLock;
    private readonly TimeSpan _cacheExpiration;
    
    public WeatherService(HttpClient httpClient)
    {
        _httpClient = httpClient;
        _cache = new Dictionary<string, WeatherData>();
        _cacheLock = new SemaphoreSlim(1, 1);
        _cacheExpiration = TimeSpan.FromMinutes(5);
    }
    
    // ๋‹จ์ผ ๋„์‹œ ๋‚ ์”จ ์กฐํšŒ (์บ์‹ฑ ํฌํ•จ)
    public async Task<WeatherData> GetWeatherAsync(
        string city, 
        CancellationToken ct = default)
    {
        // ์บ์‹œ ํ™•์ธ
        await _cacheLock.WaitAsync(ct);
        try
        {
            if (_cache.TryGetValue(city, out var cached))
            {
                if (DateTime.Now - cached.Timestamp < _cacheExpiration)
                {
                    Console.WriteLine($"โœ… ์บ์‹œ์—์„œ {city} ๋‚ ์”จ ๋ฐ˜ํ™˜");
                    return cached;
                }
            }
        }
        finally
        {
            _cacheLock.Release();
        }
        
        // API ํ˜ธ์ถœ
        Console.WriteLine($"๐ŸŒ {city} ๋‚ ์”จ API ํ˜ธ์ถœ ์ค‘...");
        
        try
        {
            // ์‹ค์ œ๋กœ๋Š” OpenWeatherMap ๊ฐ™์€ API ์‚ฌ์šฉ
            // ์—ฌ๊ธฐ์„œ๋Š” ์‹œ๋ฎฌ๋ ˆ์ด์…˜
            await Task.Delay(Random.Shared.Next(500, 1500), ct);
            
            var weather = new WeatherData
            {
                City = city,
                Temperature = Random.Shared.Next(-10, 35),
                Description = GetRandomWeather(),
                Timestamp = DateTime.Now
            };
            
            // ์บ์‹œ ์—…๋ฐ์ดํŠธ
            await _cacheLock.WaitAsync(ct);
            try
            {
                _cache[city] = weather;
            }
            finally
            {
                _cacheLock.Release();
            }
            
            return weather;
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine($"โŒ {city} ๋‚ ์”จ ์กฐํšŒ ์ทจ์†Œ๋จ");
            throw;
        }
        catch (Exception ex)
        {
            Console.WriteLine($"โŒ {city} ๋‚ ์”จ ์กฐํšŒ ์‹คํŒจ: {ex.Message}");
            throw;
        }
    }
    
    // ์—ฌ๋Ÿฌ ๋„์‹œ ๋‚ ์”จ ๋ณ‘๋ ฌ ์กฐํšŒ
    public async Task<List<WeatherData>> GetMultipleCitiesWeatherAsync(
        List<string> cities, 
        CancellationToken ct = default)
    {
        Console.WriteLine($"๐ŸŒ {cities.Count}๊ฐœ ๋„์‹œ ๋‚ ์”จ ์กฐํšŒ ์‹œ์ž‘...");
        
        var tasks = cities.Select(city => GetWeatherAsync(city, ct));
        
        try
        {
            var results = await Task.WhenAll(tasks);
            Console.WriteLine($"โœ… ๋ชจ๋“  ๋„์‹œ ๋‚ ์”จ ์กฐํšŒ ์™„๋ฃŒ!");
            return results.ToList();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"โŒ ์ผ๋ถ€ ๋„์‹œ ์กฐํšŒ ์‹คํŒจ: {ex.Message}");
            
            // ์„ฑ๊ณตํ•œ ๊ฒƒ๋งŒ ๋ฐ˜ํ™˜
            var successfulResults = tasks
                .Where(t => t.IsCompletedSuccessfully)
                .Select(t => t.Result)
                .ToList();
            
            return successfulResults;
        }
    }
    
    // ์‹ค์‹œ๊ฐ„ ๋‚ ์”จ ์—…๋ฐ์ดํŠธ ์ŠคํŠธ๋ฆผ
    public async IAsyncEnumerable<WeatherData> StreamWeatherUpdatesAsync(
        string city,
        TimeSpan interval,
        [EnumeratorCancellation] CancellationToken ct = default)
    {
        Console.WriteLine($"๐Ÿ“ก {city} ์‹ค์‹œ๊ฐ„ ๋‚ ์”จ ์ŠคํŠธ๋ฆฌ๋ฐ ์‹œ์ž‘...");
        
        while (!ct.IsCancellationRequested)
        {
            WeatherData weather;
            
            try
            {
                weather = await GetWeatherAsync(city, ct);
                yield return weather;
            }
            catch (OperationCanceledException)
            {
                Console.WriteLine($"๐Ÿ›‘ {city} ์ŠคํŠธ๋ฆฌ๋ฐ ์ค‘๋‹จ๋จ");
                yield break;
            }
            
            try
            {
                await Task.Delay(interval, ct);
            }
            catch (OperationCanceledException)
            {
                yield break;
            }
        }
    }
    
    private string GetRandomWeather()
    {
        var conditions = new[] { "๋ง‘์Œ", "ํ๋ฆผ", "๋น„", "๋ˆˆ", "์•ˆ๊ฐœ" };
        return conditions[Random.Shared.Next(conditions.Length)];
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class WeatherApp
{
    private readonly IWeatherService _weatherService;
    
    public WeatherApp(IWeatherService weatherService)
    {
        _weatherService = weatherService;
    }
    
    // ์˜ˆ์ œ 1: ๋‹จ์ผ ๋„์‹œ ์กฐํšŒ
    public async Task Example1_SingleCity()
    {
        Console.WriteLine("\n=== ์˜ˆ์ œ 1: ๋‹จ์ผ ๋„์‹œ ์กฐํšŒ ===");
        
        var weather = await _weatherService.GetWeatherAsync("์„œ์šธ");
        PrintWeather(weather);
    }
    
    // ์˜ˆ์ œ 2: ์—ฌ๋Ÿฌ ๋„์‹œ ๋ณ‘๋ ฌ ์กฐํšŒ
    public async Task Example2_MultipleCities()
    {
        Console.WriteLine("\n=== ์˜ˆ์ œ 2: ์—ฌ๋Ÿฌ ๋„์‹œ ๋ณ‘๋ ฌ ์กฐํšŒ ===");
        
        var cities = new List<string> 
        { 
            "์„œ์šธ", "๋ถ€์‚ฐ", "๋Œ€๊ตฌ", "์ธ์ฒœ", "๊ด‘์ฃผ", 
            "๋Œ€์ „", "์šธ์‚ฐ", "์ œ์ฃผ", "์ˆ˜์›", "์ฐฝ์›" 
        };
        
        var startTime = DateTime.Now;
        var results = await _weatherService.GetMultipleCitiesWeatherAsync(cities);
        var elapsed = DateTime.Now - startTime;
        
        Console.WriteLine($"\nโฑ๏ธ ์ด ์†Œ์š” ์‹œ๊ฐ„: {elapsed.TotalSeconds:F2}์ดˆ");
        Console.WriteLine($"๐Ÿ“Š ์„ฑ๊ณต: {results.Count}/{cities.Count}๊ฐœ ๋„์‹œ\n");
        
        foreach (var weather in results)
        {
            PrintWeather(weather);
        }
    }
    
    // ์˜ˆ์ œ 3: ์ทจ์†Œ ๊ฐ€๋Šฅํ•œ ์กฐํšŒ
    public async Task Example3_WithCancellation()
    {
        Console.WriteLine("\n=== ์˜ˆ์ œ 3: ์ทจ์†Œ ๊ฐ€๋Šฅํ•œ ์กฐํšŒ ===");
        
        using var cts = new CancellationTokenSource();
        
        // 2์ดˆ ํ›„ ์ž๋™ ์ทจ์†Œ
        cts.CancelAfter(TimeSpan.FromSeconds(2));
        
        try
        {
            var cities = new List<string> 
            { 
                "์„œ์šธ", "๋ถ€์‚ฐ", "๋Œ€๊ตฌ", "์ธ์ฒœ", "๊ด‘์ฃผ" 
            };
            
            var results = await _weatherService.GetMultipleCitiesWeatherAsync(
                cities, 
                cts.Token
            );
            
            Console.WriteLine($"โœ… {results.Count}๊ฐœ ๋„์‹œ ์กฐํšŒ ์™„๋ฃŒ");
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("โฐ ์‹œ๊ฐ„ ์ดˆ๊ณผ๋กœ ์ž‘์—…์ด ์ทจ์†Œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค!");
        }
    }
    
    // ์˜ˆ์ œ 4: ์‹ค์‹œ๊ฐ„ ์ŠคํŠธ๋ฆฌ๋ฐ
    public async Task Example4_Streaming()
    {
        Console.WriteLine("\n=== ์˜ˆ์ œ 4: ์‹ค์‹œ๊ฐ„ ๋‚ ์”จ ์ŠคํŠธ๋ฆฌ๋ฐ ===");
        
        using var cts = new CancellationTokenSource();
        
        // 10์ดˆ ํ›„ ์ค‘๋‹จ
        cts.CancelAfter(TimeSpan.FromSeconds(10));
        
        var updateCount = 0;
        
        await foreach (var weather in _weatherService.StreamWeatherUpdatesAsync(
            "์„œ์šธ", 
            TimeSpan.FromSeconds(2), 
            cts.Token))
        {
            updateCount++;
            Console.WriteLine($"\n[์—…๋ฐ์ดํŠธ #{updateCount}]");
            PrintWeather(weather);
        }
        
        Console.WriteLine($"\n์ด {updateCount}๋ฒˆ ์—…๋ฐ์ดํŠธ๋จ");
    }
    
    // ์˜ˆ์ œ 5: ํƒ€์ž„์•„์›ƒ ์ฒ˜๋ฆฌ
    public async Task Example5_WithTimeout()
    {
        Console.WriteLine("\n=== ์˜ˆ์ œ 5: ํƒ€์ž„์•„์›ƒ ์ฒ˜๋ฆฌ ===");
        
        using var cts = new CancellationTokenSource();
        cts.CancelAfter(TimeSpan.FromSeconds(1));
        
        try
        {
            var weather = await _weatherService.GetWeatherAsync("์„œ์šธ", cts.Token);
            PrintWeather(weather);
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("โฐ ์š”์ฒญ ์‹œ๊ฐ„ ์ดˆ๊ณผ!");
        }
    }
    
    private void PrintWeather(WeatherData weather)
    {
        Console.WriteLine($"๐ŸŒ† ๋„์‹œ: {weather.City}");
        Console.WriteLine($"๐ŸŒก๏ธ ์˜จ๋„: {weather.Temperature}ยฐC");
        Console.WriteLine($"โ˜๏ธ ๋‚ ์”จ: {weather.Description}");
        Console.WriteLine($"โฐ ์‹œ๊ฐ„: {weather.Timestamp:HH:mm:ss}");
        Console.WriteLine();
    }
}

// ๋ฉ”์ธ ํ”„๋กœ๊ทธ๋žจ
public class Program
{
    public static async Task Main(string[] args)
    {
        Console.WriteLine("๐ŸŒค๏ธ ๋น„๋™๊ธฐ ๋‚ ์”จ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ์‹œ์ž‘!\n");
        
        using var httpClient = new HttpClient();
        var weatherService = new WeatherService(httpClient);
        var app = new WeatherApp(weatherService);
        
        try
        {
            // ๋ชจ๋“  ์˜ˆ์ œ ์‹คํ–‰
            await app.Example1_SingleCity();
            await app.Example2_MultipleCities();
            await app.Example3_WithCancellation();
            await app.Example4_Streaming();
            await app.Example5_WithTimeout();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"โŒ ์˜ค๋ฅ˜ ๋ฐœ์ƒ: {ex.Message}");
        }
        
        Console.WriteLine("\nโœ… ํ”„๋กœ๊ทธ๋žจ ์ข…๋ฃŒ");
    }
}

๐ŸŽ“ ์ด ์˜ˆ์ œ์—์„œ ๋ฐฐ์šด ํ•ต์‹ฌ ๊ฐœ๋…๋“ค

1. ์บ์‹ฑ๊ณผ ๋™๊ธฐํ™”
SemaphoreSlim์„ ์‚ฌ์šฉํ•œ ์Šค๋ ˆ๋“œ ์•ˆ์ „ํ•œ ์บ์‹œ ๊ตฌํ˜„

2. ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ
Task.WhenAll๋กœ ์—ฌ๋Ÿฌ API ํ˜ธ์ถœ์„ ๋™์‹œ์— ์ฒ˜๋ฆฌ

3. ์ทจ์†Œ ํ† ํฐ
CancellationToken์œผ๋กœ ์ž‘์—… ์ทจ์†Œ ๋ฐ ํƒ€์ž„์•„์›ƒ ๊ตฌํ˜„

4. ๋น„๋™๊ธฐ ์ŠคํŠธ๋ฆผ
IAsyncEnumerable๋กœ ์‹ค์‹œ๊ฐ„ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆฌ๋ฐ

5. ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
๋ถ€๋ถ„ ์‹คํŒจ ์‹œ๋‚˜๋ฆฌ์˜ค ์ฒ˜๋ฆฌ ๋ฐ ์šฐ์•„ํ•œ ๋ณต๊ตฌ

๐Ÿšจ ํ”ํ•œ ์‹ค์ˆ˜์™€ ์•ˆํ‹ฐํŒจํ„ด

๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ํ•˜๋‹ค ๋ณด๋ฉด ๋ˆ„๊ตฌ๋‚˜ ์‹ค์ˆ˜๋ฅผ ํ•ด. ํ•˜์ง€๋งŒ ์ด๋Ÿฐ ์‹ค์ˆ˜๋“ค์„ ๋ฏธ๋ฆฌ ์•Œ๊ณ  ์žˆ์œผ๋ฉด ํ”ผํ•  ์ˆ˜ ์žˆ์ง€! ๐Ÿ˜Š

โŒ ์•ˆํ‹ฐํŒจํ„ด 1: async void ๋‚จ์šฉ

// ๋‚˜์œ ์˜ˆ โŒ
public async void ProcessDataBad()
{
    await Task.Delay(1000);
    throw new Exception("์˜ค๋ฅ˜!"); // ์ด ์˜ˆ์™ธ๋Š” ์žก์„ ์ˆ˜ ์—†์–ด!
}

// ์ข‹์€ ์˜ˆ โœ…
public async Task ProcessDataGood()
{
    await Task.Delay(1000);
    throw new Exception("์˜ค๋ฅ˜!"); // ์ด ์˜ˆ์™ธ๋Š” ํ˜ธ์ถœ์ž๊ฐ€ ์ฒ˜๋ฆฌ ๊ฐ€๋Šฅ
}

// async void๋Š” ์ด๋ฒคํŠธ ํ•ธ๋“ค๋Ÿฌ์—์„œ๋งŒ!
private async void Button_Click(object sender, EventArgs e)
{
    try
    {
        await ProcessDataGood();
    }
    catch (Exception ex)
    {
        MessageBox.Show($"์˜ค๋ฅ˜: {ex.Message}");
    }
}

โŒ ์•ˆํ‹ฐํŒจํ„ด 2: .Result๋‚˜ .Wait() ์‚ฌ์šฉ

// ๋‚˜์œ ์˜ˆ โŒ - ๋ฐ๋“œ๋ฝ ๋ฐœ์ƒ ๊ฐ€๋Šฅ!
public string GetDataBad()
{
    var task = GetDataAsync();
    return task.Result; // UI ์Šค๋ ˆ๋“œ์—์„œ ์ด๋Ÿฌ๋ฉด ๋ฉˆ์ถฐ๋ฒ„๋ ค!
}

// ์ข‹์€ ์˜ˆ โœ…
public async Task<string> GetDataGood()
{
    return await GetDataAsync();
}

// ์ •๋ง ๋™๊ธฐ ๋ฉ”์„œ๋“œ๊ฐ€ ํ•„์š”ํ•˜๋‹ค๋ฉด
public string GetDataSync()
{
    // GetAwaiter().GetResult()๊ฐ€ .Result๋ณด๋‹ค ๋‚ซ๊ธด ํ•˜์ง€๋งŒ
    // ์—ฌ์ „ํžˆ ๊ถŒ์žฅํ•˜์ง€ ์•Š์Œ
    return GetDataAsync().GetAwaiter().GetResult();
}

์™œ ๋ฐ๋“œ๋ฝ์ด ๋ฐœ์ƒํ• ๊นŒ?
1. UI ์Šค๋ ˆ๋“œ๊ฐ€ .Result๋ฅผ ํ˜ธ์ถœํ•˜๋ฉฐ ๋ธ”๋กœํ‚น๋จ
2. async ๋ฉ”์„œ๋“œ๊ฐ€ ์™„๋ฃŒ๋˜๋ ค๋ฉด UI ์Šค๋ ˆ๋“œ๋กœ ๋Œ์•„๊ฐ€์•ผ ํ•จ
3. ํ•˜์ง€๋งŒ UI ์Šค๋ ˆ๋“œ๋Š” .Result๋ฅผ ๊ธฐ๋‹ค๋ฆฌ๋ฉฐ ๋ธ”๋กœํ‚น ์ค‘
4. ์„œ๋กœ ๊ธฐ๋‹ค๋ฆฌ๋Š” ๋ฐ๋“œ๋ฝ ๋ฐœ์ƒ! ๐Ÿ’€

โŒ ์•ˆํ‹ฐํŒจํ„ด 3: async ๋ฉ”์„œ๋“œ์—์„œ ๋™๊ธฐ ์ฝ”๋“œ ํ˜ธ์ถœ

// ๋‚˜์œ ์˜ˆ โŒ
public async Task<string> ReadFileBad(string path)
{
    // File.ReadAllText๋Š” ๋™๊ธฐ ๋ฉ”์„œ๋“œ!
    // ์Šค๋ ˆ๋“œ๋ฅผ ๋ธ”๋กœํ‚น์‹œ์ผœ
    return await Task.Run(() => File.ReadAllText(path));
}

// ์ข‹์€ ์˜ˆ โœ…
public async Task<string> ReadFileGood(string path)
{
    // ์ง„์งœ ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ
    return await File.ReadAllTextAsync(path);
}

โŒ ์•ˆํ‹ฐํŒจํ„ด 4: ๋ถˆํ•„์š”ํ•œ async/await

// ๋‚˜์œ ์˜ˆ โŒ - ๋ถˆํ•„์š”ํ•œ ์ƒํƒœ ๋จธ์‹  ์ƒ์„ฑ
public async Task<string> GetDataBad()
{
    return await _httpClient.GetStringAsync("url");
}

// ์ข‹์€ ์˜ˆ โœ… - Task๋ฅผ ๊ทธ๋Œ€๋กœ ๋ฐ˜ํ™˜
public Task<string> GetDataGood()
{
    return _httpClient.GetStringAsync("url");
}

// ํ•˜์ง€๋งŒ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ๊ฐ€ ํ•„์š”ํ•˜๋ฉด async/await ์‚ฌ์šฉ
public async Task<string> GetDataWithErrorHandling()
{
    try
    {
        return await _httpClient.GetStringAsync("url");
    }
    catch (HttpRequestException ex)
    {
        // ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
        return null;
    }
}

โŒ ์•ˆํ‹ฐํŒจํ„ด 5: ๋น„๋™๊ธฐ ์ƒ์„ฑ์ž

// ๋‚˜์œ ์˜ˆ โŒ - ์ƒ์„ฑ์ž๋Š” async๊ฐ€ ๋  ์ˆ˜ ์—†์–ด!
public class BadService
{
    public BadService()
    {
        // ์ด๋ ‡๊ฒŒ ํ•˜๋ฉด ์•ˆ ๋ผ!
        InitializeAsync().Wait();
    }
    
    private async Task InitializeAsync()
    {
        await Task.Delay(1000);
    }
}

// ์ข‹์€ ์˜ˆ โœ… - ํŒฉํ† ๋ฆฌ ํŒจํ„ด ์‚ฌ์šฉ
public class GoodService
{
    private GoodService()
    {
        // private ์ƒ์„ฑ์ž
    }
    
    public static async Task<GoodService> CreateAsync()
    {
        var service = new GoodService();
        await service.InitializeAsync();
        return service;
    }
    
    private async Task InitializeAsync()
    {
        await Task.Delay(1000);
    }
}

// ์‚ฌ์šฉ
var service = await GoodService.CreateAsync();

โŒ ์•ˆํ‹ฐํŒจํ„ด 6: ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ๋ฅผ ๋™๊ธฐ์ ์œผ๋กœ ์‹คํ–‰

// ๋‚˜์œ ์˜ˆ โŒ
public void ProcessItems(List<Item> items)
{
    foreach (var item in items)
    {
        // ์ˆœ์ฐจ์ ์œผ๋กœ ์‹คํ–‰ - ๋А๋ฆผ!
        ProcessItemAsync(item).Wait();
    }
}

// ์ข‹์€ ์˜ˆ โœ…
public async Task ProcessItems(List<Item> items)
{
    // ๋ณ‘๋ ฌ๋กœ ์‹คํ–‰ - ๋น ๋ฆ„!
    var tasks = items.Select(item => ProcessItemAsync(item));
    await Task.WhenAll(tasks);
}

โš™๏ธ ์„ฑ๋Šฅ ์ตœ์ ํ™” ํŒ

๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ์ง„์งœ ํž˜์€ ์„ฑ๋Šฅ ์ตœ์ ํ™”์— ์žˆ์–ด! ๋ช‡ ๊ฐ€์ง€ ํŒ์„ ์•Œ๋ ค์ค„๊ฒŒ. ๐Ÿš€

๐Ÿ’Ž ์ตœ์ ํ™” ํŒ 1: Task ์žฌ์‚ฌ์šฉ

public class TaskReusageExample
{
    // ๋‚˜์œ ์˜ˆ โŒ - ๋งค๋ฒˆ ์ƒˆ๋กœ์šด Task ์ƒ์„ฑ
    public Task<int> GetCachedValueBad()
    {
        return Task.FromResult(42); // ๋งค๋ฒˆ ํž™ ํ• ๋‹น!
    }
    
    // ์ข‹์€ ์˜ˆ โœ… - Task ์บ์‹ฑ
    private static readonly Task<int> _cachedTask = Task.FromResult(42);
    
    public Task<int> GetCachedValueGood()
    {
        return _cachedTask; // ์žฌ์‚ฌ์šฉ!
    }
    
    // ๋” ๋‚˜์€ ์˜ˆ โœ… - ValueTask ์‚ฌ์šฉ
    public ValueTask<int> GetCachedValueBest()
    {
        return new ValueTask<int>(42); // ํž™ ํ• ๋‹น ์—†์Œ!
    }
}

๐Ÿ’Ž ์ตœ์ ํ™” ํŒ 2: ๋ฐฐ์น˜ ์ฒ˜๋ฆฌ

public class BatchProcessingExample
{
    // ๋‚˜์œ ์˜ˆ โŒ - ํ•˜๋‚˜์”ฉ ์ฒ˜๋ฆฌ
    public async Task ProcessItemsOneByOne(List<int> items)
    {
        foreach (var item in items)
        {
            await ProcessAsync(item);
        }
    }
    
    // ์ข‹์€ ์˜ˆ โœ… - ๋ฐฐ์น˜๋กœ ์ฒ˜๋ฆฌ
    public async Task ProcessItemsInBatches(
        List<int> items, 
        int batchSize = 10)
    {
        for (int i = 0; i < items.Count; i += batchSize)
        {
            var batch = items.Skip(i).Take(batchSize);
            var tasks = batch.Select(item => ProcessAsync(item));
            await Task.WhenAll(tasks);
        }
    }
    
    private async Task ProcessAsync(int item)
    {
        await Task.Delay(100);
    }
}

๐Ÿ’Ž ์ตœ์ ํ™” ํŒ 3: ์กฐ๊ธฐ ๋ฐ˜ํ™˜

public class EarlyReturnExample
{
    private Dictionary<string, string> _cache = new();
    
    // ๋‚˜์œ ์˜ˆ โŒ
    public async Task<string> GetDataBad(string key)
    {
        string result;
        
        if (_cache.ContainsKey(key))
        {
            result = _cache[key];
        }
        else
        {
            result = await FetchDataAsync(key);
            _cache[key] = result;
        }
        
        return result;
    }
    
    // ์ข‹์€ ์˜ˆ โœ… - ์กฐ๊ธฐ ๋ฐ˜ํ™˜์œผ๋กœ ๋ถˆํ•„์š”ํ•œ await ์ œ๊ฑฐ
    public async Task<string> GetDataGood(string key)
    {
        if (_cache.TryGetValue(key, out var cached))
        {
            return cached; // ๋™๊ธฐ์ ์œผ๋กœ ์ฆ‰์‹œ ๋ฐ˜ํ™˜
        }
        
        var result = await FetchDataAsync(key);
        _cache[key] = result;
        return result;
    }
    
    // ๋” ๋‚˜์€ ์˜ˆ โœ… - ValueTask ์‚ฌ์šฉ
    public async ValueTask<string> GetDataBest(string key)
    {
        if (_cache.TryGetValue(key, out var cached))
        {
            return cached; // ํž™ ํ• ๋‹น ์—†์ด ๋ฐ˜ํ™˜!
        }
        
        var result = await FetchDataAsync(key);
        _cache[key] = result;
        return result;
    }
    
    private async Task<string> FetchDataAsync(string key)
    {
        await Task.Delay(100);
        return $"Data for {key}";
    }
}

๐Ÿ’Ž ์ตœ์ ํ™” ํŒ 4: ์ ์ ˆํ•œ ๋™์‹œ์„ฑ ์ œ์–ด

public class ConcurrencyControlExample
{
    // ๋™์‹œ ์‹คํ–‰ ์ˆ˜ ์ œํ•œ
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5);
    
    public async Task<List<Result>> ProcessWithLimit(List<Item> items)
    {
        var tasks = items.Select(async item =>
        {
            await _semaphore.WaitAsync();
            try
            {
                return await ProcessItemAsync(item);
            }
            finally
            {
                _semaphore.Release();
            }
        });
        
        return (await Task.WhenAll(tasks)).ToList();
    }
    
    // ๋˜๋Š” Parallel.ForEachAsync ์‚ฌ์šฉ (.NET 6+)
    public async Task ProcessWithParallel(List<Item> items)
    {
        await Parallel.ForEachAsync(
            items,
            new ParallelOptions { MaxDegreeOfParallelism = 5 },
            async (item, ct) =>
            {
                await ProcessItemAsync(item);
            }
        );
    }
    
    private async Task<Result> ProcessItemAsync(Item item)
    {
        await Task.Delay(100);
        return new Result();
    }
}

public class Item { }
public class Result { }

๐ŸŽฏ ์‹ค๋ฌด์—์„œ ์ž์ฃผ ์“ฐ๋Š” ํŒจํ„ด

์‹ค์ œ ํ”„๋กœ์ ํŠธ์—์„œ ์ •๋ง ์œ ์šฉํ•œ ํŒจํ„ด๋“ค์„ ์†Œ๊ฐœํ• ๊ฒŒ! ์ด๋Ÿฐ ํŒจํ„ด๋“ค์€ ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ๋„ ๋งŽ์ด ์‚ฌ์šฉ๋˜๋Š” ๊ฒ€์ฆ๋œ ๋ฐฉ๋ฒ•๋“ค์ด์•ผ. ๐Ÿ’ผ

๐ŸŽจ ํŒจํ„ด 1: Retry ํŒจํ„ด

public class RetryPattern
{
    // ์žฌ์‹œ๋„ ๋กœ์ง์ด ์žˆ๋Š” HTTP ํ˜ธ์ถœ
    public async Task<T> ExecuteWithRetry<T>(
        Func<Task<T>> operation,
        int maxRetries = 3,
        TimeSpan? delay = null)
    {
        delay ??= TimeSpan.FromSeconds(1);
        
        for (int i = 0; i < maxRetries; i++)
        {
            try
            {
                return await operation();
            }
            catch (Exception ex) when (i < maxRetries - 1)
            {
                Console.WriteLine($"์‹œ๋„ {i + 1} ์‹คํŒจ: {ex.Message}");
                Console.WriteLine($"{delay.Value.TotalSeconds}์ดˆ ํ›„ ์žฌ์‹œ๋„...");
                
                await Task.Delay(delay.Value);
                
                // ์ง€์ˆ˜ ๋ฐฑ์˜คํ”„ (Exponential Backoff)
                delay = TimeSpan.FromSeconds(delay.Value.TotalSeconds * 2);
            }
        }
        
        // ๋งˆ์ง€๋ง‰ ์‹œ๋„
        return await operation();
    }
    
    // ์‚ฌ์šฉ ์˜ˆ์‹œ
    public async Task<string> FetchDataWithRetry(string url)
    {
        return await ExecuteWithRetry(async () =>
        {
            using var client = new HttpClient();
            return await client.GetStringAsync(url);
        });
    }
}

// Polly ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•œ ๊ณ ๊ธ‰ ๋ฒ„์ „
// Install-Package Polly
public class PollyRetryExample
{
    public async Task<string> FetchDataWithPolly(string url)
    {
        var retryPolicy = Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: attempt => 
                    TimeSpan.FromSeconds(Math.Pow(2, attempt)),
                onRetry: (exception, timeSpan, retryCount, context) =>
                {
                    Console.WriteLine($"์žฌ์‹œ๋„ {retryCount}: {exception.Message}");
                }
            );
        
        return await retryPolicy.ExecuteAsync(async () =>
        {
            using var client = new HttpClient();
            return await client.GetStringAsync(url);
        });
    }
}

๐ŸŽจ ํŒจํ„ด 2: Circuit Breaker ํŒจํ„ด

public class CircuitBreaker
{
    private int _failureCount = 0;
    private DateTime _lastFailureTime = DateTime.MinValue;
    private readonly int _failureThreshold;
    private readonly TimeSpan _timeout;
    private CircuitState _state = CircuitState.Closed;
    
    public CircuitBreaker(int failureThreshold = 5, TimeSpan? timeout = null)
    {
        _failureThreshold = failureThreshold;
        _timeout = timeout ?? TimeSpan.FromMinutes(1);
    }
    
    public async Task<T> ExecuteAsync<T>(Func<Task<T>> operation)
    {
        if (_state == CircuitState.Open)
        {
            if (DateTime.Now - _lastFailureTime > _timeout)
            {
                _state = CircuitState.HalfOpen;
                Console.WriteLine("๐Ÿ”„ Circuit Breaker: Half-Open ์ƒํƒœ");
            }
            else
            {
                throw new Exception("Circuit Breaker๊ฐ€ Open ์ƒํƒœ์ž…๋‹ˆ๋‹ค!");
            }
        }
        
        try
        {
            var result = await operation();
            
            if (_state == CircuitState.HalfOpen)
            {
                _state = CircuitState.Closed;
                _failureCount = 0;
                Console.WriteLine("โœ… Circuit Breaker: Closed ์ƒํƒœ๋กœ ๋ณต๊ตฌ");
            }
            
            return result;
        }
        catch (Exception ex)
        {
            _failureCount++;
            _lastFailureTime = DateTime.Now;
            
            if (_failureCount >= _failureThreshold)
            {
                _state = CircuitState.Open;
                Console.WriteLine($"๐Ÿ”ด Circuit Breaker: Open ์ƒํƒœ (์‹คํŒจ {_failureCount}ํšŒ)");
            }
            
            throw;
        }
    }
}

public enum CircuitState
{
    Closed,   // ์ •์ƒ ์ž‘๋™
    Open,     // ์ฐจ๋‹จ๋จ
    HalfOpen  // ๋ณต๊ตฌ ์‹œ๋„ ์ค‘
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class ServiceWithCircuitBreaker
{
    private readonly CircuitBreaker _circuitBreaker = new CircuitBreaker();
    
    public async Task<string> CallExternalService(string url)
    {
        return await _circuitBreaker.ExecuteAsync(async () =>
        {
            using var client = new HttpClient();
            return await client.GetStringAsync(url);
        });
    }
}

๐ŸŽจ ํŒจํ„ด 3: ์บ์‹ฑ ํŒจํ„ด

public class CachePattern<TKey, TValue>
{
    private readonly Dictionary<TKey, CacheEntry<TValue>> _cache = new();
    private readonly SemaphoreSlim _lock = new SemaphoreSlim(1, 1);
    private readonly TimeSpan _expiration;
    
    public CachePattern(TimeSpan expiration)
    {
        _expiration = expiration;
    }
    
    public async Task<TValue> GetOrAddAsync(
        TKey key,
        Func<Task<TValue>> factory)
    {
        // ์บ์‹œ ํ™•์ธ (๋ฝ ์—†์ด)
        if (_cache.TryGetValue(key, out var entry))
        {
            if (!entry.IsExpired)
            {
                return entry.Value;
            }
        }
        
        // ์บ์‹œ ๋ฏธ์Šค - ๋ฝ ํš๋“
        await _lock.WaitAsync();
        try
        {
            // Double-check locking
            if (_cache.TryGetValue(key, out entry) && !entry.IsExpired)
            {
                return entry.Value;
            }
            
            // ๊ฐ’ ์ƒ์„ฑ
            var value = await factory();
            
            _cache[key] = new CacheEntry<TValue>
            {
                Value = value,
                ExpirationTime = DateTime.Now + _expiration
            };
            
            return value;
        }
        finally
        {
            _lock.Release();
        }
    }
    
    public void Clear()
    {
        _lock.Wait();
        try
        {
            _cache.Clear();
        }
        finally
        {
            _lock.Release();
        }
    }
}

public class CacheEntry<T>
{
    public T Value { get; set; }
    public DateTime ExpirationTime { get; set; }
    public bool IsExpired => DateTime.Now > ExpirationTime;
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class UserService
{
    private readonly CachePattern<int, User> _userCache;
    
    public UserService()
    {
        _userCache = new CachePattern<int, User>(TimeSpan.FromMinutes(5));
    }
    
    public async Task<User> GetUserAsync(int userId)
    {
        return await _userCache.GetOrAddAsync(userId, async () =>
        {
            // DB์—์„œ ์‚ฌ์šฉ์ž ์กฐํšŒ
            await Task.Delay(100); // DB ์ฟผ๋ฆฌ ์‹œ๋ฎฌ๋ ˆ์ด์…˜
            return new User { Id = userId, Name = $"User{userId}" };
        });
    }
}

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
}

๐ŸŽจ ํŒจํ„ด 4: ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—… ํ

public class BackgroundTaskQueue
{
    private readonly Channel<Func<CancellationToken, Task>> _queue;
    
    public BackgroundTaskQueue(int capacity = 100)
    {
        var options = new BoundedChannelOptions(capacity)
        {
            FullMode = BoundedChannelFullMode.Wait
        };
        
        _queue = Channel.CreateBounded<Func<CancellationToken, Task>>(options);
    }
    
    public async Task QueueBackgroundWorkItemAsync(
        Func<CancellationToken, Task> workItem)
    {
        if (workItem == null)
        {
            throw new ArgumentNullException(nameof(workItem));
        }
        
        await _queue.Writer.WriteAsync(workItem);
    }
    
    public async Task<Func<CancellationToken, Task>> DequeueAsync(
        CancellationToken cancellationToken)
    {
        var workItem = await _queue.Reader.ReadAsync(cancellationToken);
        return workItem;
    }
}

// ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์„œ๋น„์Šค
public class QueuedHostedService : BackgroundService
{
    private readonly BackgroundTaskQueue _taskQueue;
    
    public QueuedHostedService(BackgroundTaskQueue taskQueue)
    {
        _taskQueue = taskQueue;
    }
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        Console.WriteLine("๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—… ํ ์‹œ์ž‘");
        
        while (!stoppingToken.IsCancellationRequested)
        {
            var workItem = await _taskQueue.DequeueAsync(stoppingToken);
            
            try
            {
                await workItem(stoppingToken);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"์ž‘์—… ์‹คํ–‰ ์˜ค๋ฅ˜: {ex.Message}");
            }
        }
        
        Console.WriteLine("๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—… ํ ์ข…๋ฃŒ");
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class EmailService
{
    private readonly BackgroundTaskQueue _taskQueue;
    
    public EmailService(BackgroundTaskQueue taskQueue)
    {
        _taskQueue = taskQueue;
    }
    
    public async Task SendEmailAsync(string to, string subject, string body)
    {
        // ์ด๋ฉ”์ผ ์ „์†ก์„ ๋ฐฑ๊ทธ๋ผ์šด๋“œ๋กœ ํ์ž‰
        await _taskQueue.QueueBackgroundWorkItemAsync(async ct =>
        {
            Console.WriteLine($"์ด๋ฉ”์ผ ์ „์†ก ์ค‘: {to}");
            await Task.Delay(2000, ct); // ์ „์†ก ์‹œ๋ฎฌ๋ ˆ์ด์…˜
            Console.WriteLine($"์ด๋ฉ”์ผ ์ „์†ก ์™„๋ฃŒ: {to}");
        });
        
        Console.WriteLine("์ด๋ฉ”์ผ์ด ํ์— ์ถ”๊ฐ€๋˜์—ˆ์Šต๋‹ˆ๋‹ค.");
    }
}

๐Ÿ”ฌ ๋””๋ฒ„๊น…๊ณผ ๋ชจ๋‹ˆํ„ฐ๋ง

๋น„๋™๊ธฐ ์ฝ”๋“œ๋Š” ๋””๋ฒ„๊น…์ด ๊นŒ๋‹ค๋กœ์šธ ์ˆ˜ ์žˆ์–ด. ํ•˜์ง€๋งŒ ์˜ฌ๋ฐ”๋ฅธ ๋„๊ตฌ์™€ ๊ธฐ๋ฒ•์„ ์•Œ๋ฉด ํ›จ์”ฌ ์‰ฌ์›Œ์ ธ! ๐Ÿ”

๐Ÿ› ๏ธ Visual Studio ๋””๋ฒ„๊น… ํŒ

1. Parallel Stacks ์ฐฝ ์‚ฌ์šฉ
Debug โ†’ Windows โ†’ Parallel Stacks
์—ฌ๋Ÿฌ Task์˜ ์‹คํ–‰ ์ƒํƒœ๋ฅผ ์‹œ๊ฐ์ ์œผ๋กœ ๋ณผ ์ˆ˜ ์žˆ์–ด!

2. Tasks ์ฐฝ ์‚ฌ์šฉ
Debug โ†’ Windows โ†’ Tasks
๋ชจ๋“  Task์˜ ์ƒํƒœ, ID, ์œ„์น˜๋ฅผ ํ•œ๋ˆˆ์— ํ™•์ธ

3. Async/Await ๋””๋ฒ„๊น…
Call Stack ์ฐฝ์—์„œ [Async] ํ‘œ์‹œ๋ฅผ ํ™•์ธ
๋น„๋™๊ธฐ ํ˜ธ์ถœ ์ฒด์ธ์„ ์ถ”์ ํ•  ์ˆ˜ ์žˆ์–ด

4. ์ค‘๋‹จ์  ์กฐ๊ฑด ์„ค์ •
ํŠน์ • Task ID๋‚˜ ์Šค๋ ˆ๋“œ์—์„œ๋งŒ ์ค‘๋‹จ๋˜๋„๋ก ์„ค์ • ๊ฐ€๋Šฅ

๐Ÿ“Š ์„ฑ๋Šฅ ๋ชจ๋‹ˆํ„ฐ๋ง

public class PerformanceMonitoring
{
    // ์‹คํ–‰ ์‹œ๊ฐ„ ์ธก์ •
    public async Task<T> MeasureExecutionTime<T>(
        Func<Task<T>> operation,
        string operationName)
    {
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            var result = await operation();
            stopwatch.Stop();
            
            Console.WriteLine($"โœ… {operationName}: {stopwatch.ElapsedMilliseconds}ms");
            
            return result;
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            Console.WriteLine($"โŒ {operationName} ์‹คํŒจ: {stopwatch.ElapsedMilliseconds}ms");
            throw;
        }
    }
    
    // Task ์ƒํƒœ ๋ชจ๋‹ˆํ„ฐ๋ง
    public void MonitorTask(Task task, string taskName)
    {
        task.ContinueWith(t =>
        {
            if (t.IsCompletedSuccessfully)
            {
                Console.WriteLine($"โœ… {taskName} ์™„๋ฃŒ");
            }
            else if (t.IsFaulted)
            {
                Console.WriteLine($"โŒ {taskName} ์‹คํŒจ: {t.Exception?.Message}");
            }
            else if (t.IsCanceled)
            {
                Console.WriteLine($"โน๏ธ {taskName} ์ทจ์†Œ๋จ");
            }
        });
    }
    
    // ๋™์‹œ ์‹คํ–‰ ์ˆ˜ ์ถ”์ 
    public class ConcurrencyTracker
    {
        private int _currentCount = 0;
        private int _maxCount = 0;
        private readonly object _lock = new object();
        
        public IDisposable Track()
        {
            lock (_lock)
            {
                _currentCount++;
                if (_currentCount > _maxCount)
                {
                    _maxCount = _currentCount;
                    Console.WriteLine($"๐Ÿ“Š ์ตœ๋Œ€ ๋™์‹œ ์‹คํ–‰: {_maxCount}");
                }
            }
            
            return new DisposableAction(() =>
            {
                lock (_lock)
                {
                    _currentCount--;
                }
            });
        }
    }
    
    private class DisposableAction : IDisposable
    {
        private readonly Action _action;
        
        public DisposableAction(Action action)
        {
            _action = action;
        }
        
        public void Dispose()
        {
            _action();
        }
    }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class MonitoredService
{
    private readonly PerformanceMonitoring _monitoring = new();
    private readonly PerformanceMonitoring.ConcurrencyTracker _tracker = new();
    
    public async Task<string> ProcessDataAsync(string input)
    {
        using (_tracker.Track())
        {
            return await _monitoring.MeasureExecutionTime(
                async () =>
                {
                    await Task.Delay(Random.Shared.Next(100, 500));
                    return $"Processed: {input}";
                },
                $"ProcessData({input})"
            );
        }
    }
}

๐Ÿ” ๋กœ๊น… ๋ฒ ์ŠคํŠธ ํ”„๋ž™ํ‹ฐ์Šค

public class AsyncLogging
{
    private readonly ILogger _logger;
    
    public async Task<Result> ProcessWithLogging(Request request)
    {
        var correlationId = Guid.NewGuid();
        
        _logger.LogInformation(
            "[{CorrelationId}] ์ฒ˜๋ฆฌ ์‹œ์ž‘: {RequestId}",
            correlationId,
            request.Id
        );
        
        try
        {
            var result = await ProcessAsync(request);
            
            _logger.LogInformation(
                "[{CorrelationId}] ์ฒ˜๋ฆฌ ์™„๋ฃŒ: {RequestId}, ๊ฒฐ๊ณผ: {ResultCode}",
                correlationId,
                request.Id,
                result.Code
            );
            
            return result;
        }
        catch (Exception ex)
        {
            _logger.LogError(
                ex,
                "[{CorrelationId}] ์ฒ˜๋ฆฌ ์‹คํŒจ: {RequestId}",
                correlationId,
                request.Id
            );
            
            throw;
        }
    }
    
    private async Task<Result> ProcessAsync(Request request)
    {
        await Task.Delay(100);
        return new Result { Code = 200 };
    }
}

public interface ILogger
{
    void LogInformation(string message, params object[] args);
    void LogError(Exception ex, string message, params object[] args);
}

public class Request
{
    public int Id { get; set; }
}

public class Result
{
    public int Code { get; set; }
}

๐ŸŒŸ ์‹ค์ „ ํ”„๋กœ์ ํŠธ: ๊ณ ์„ฑ๋Šฅ ์›น ํฌ๋กค๋Ÿฌ

์ง€๊ธˆ๊นŒ์ง€ ๋ฐฐ์šด ๋ชจ๋“  ๊ฒƒ์„ ์ข…ํ•ฉํ•ด์„œ ์‹ค์ „ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ณด์ž! ์—ฌ๋Ÿฌ ์›น์‚ฌ์ดํŠธ๋ฅผ ๋™์‹œ์— ํฌ๋กค๋งํ•˜๋Š” ๊ณ ์„ฑ๋Šฅ ํฌ๋กค๋Ÿฌ์•ผ. ๐Ÿ•ท๏ธ

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

public class WebCrawler
{
    private readonly HttpClient _httpClient;
    private readonly SemaphoreSlim _rateLimiter;
    private readonly ConcurrentDictionary<string, CrawlResult> _results;
    private readonly PerformanceMetrics _metrics;
    
    public WebCrawler(int maxConcurrency = 10)
    {
        _httpClient = new HttpClient
        {
            Timeout = TimeSpan.FromSeconds(30)
        };
        
        _rateLimiter = new SemaphoreSlim(maxConcurrency);
        _results = new ConcurrentDictionary<string, CrawlResult>();
        _metrics = new PerformanceMetrics();
    }
    
    // ๋ฉ”์ธ ํฌ๋กค๋ง ๋ฉ”์„œ๋“œ
    public async Task<CrawlSummary> CrawlAsync(
        List<string> urls,
        CancellationToken cancellationToken = default)
    {
        Console.WriteLine($"๐Ÿ•ท๏ธ ํฌ๋กค๋ง ์‹œ์ž‘: {urls.Count}๊ฐœ URL");
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            // ๋ชจ๋“  URL์„ ๋ณ‘๋ ฌ๋กœ ํฌ๋กค๋ง
            var tasks = urls.Select(url => 
                CrawlUrlAsync(url, cancellationToken)
            );
            
            await Task.WhenAll(tasks);
            
            stopwatch.Stop();
            
            return new CrawlSummary
            {
                TotalUrls = urls.Count,
                SuccessCount = _results.Count(r => r.Value.Success),
                FailureCount = _results.Count(r => !r.Value.Success),
                TotalTime = stopwatch.Elapsed,
                Results = _results.Values.ToList(),
                Metrics = _metrics.GetSnapshot()
            };
        }
        catch (Exception ex)
        {
            Console.WriteLine($"โŒ ํฌ๋กค๋ง ์˜ค๋ฅ˜: {ex.Message}");
            throw;
        }
    }
    
    // ๊ฐœ๋ณ„ URL ํฌ๋กค๋ง
    private async Task CrawlUrlAsync(
        string url,
        CancellationToken cancellationToken)
    {
        await _rateLimiter.WaitAsync(cancellationToken);
        
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            _metrics.IncrementAttempts();
            
            Console.WriteLine($"๐Ÿ“ฅ ํฌ๋กค๋ง ์ค‘: {url}");
            
            // HTTP ์š”์ฒญ
            var response = await _httpClient.GetAsync(url, cancellationToken);
            response.EnsureSuccessStatusCode();
            
            var content = await response.Content.ReadAsStringAsync();
            
            stopwatch.Stop();
            
            // ๊ฒฐ๊ณผ ์ €์žฅ
            var result = new CrawlResult
            {
                Url = url,
                Success = true,
                StatusCode = (int)response.StatusCode,
                ContentLength = content.Length,
                ResponseTime = stopwatch.Elapsed,
                Timestamp = DateTime.Now
            };
            
            _results[url] = result;
            _metrics.IncrementSuccess();
            _metrics.RecordResponseTime(stopwatch.Elapsed);
            
            Console.WriteLine(
                $"โœ… ์™„๋ฃŒ: {url} ({content.Length} bytes, {stopwatch.ElapsedMilliseconds}ms)"
            );
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine($"โน๏ธ ์ทจ์†Œ๋จ: {url}");
            
            _results[url] = new CrawlResult
            {
                Url = url,
                Success = false,
                ErrorMessage = "์ž‘์—…์ด ์ทจ์†Œ๋˜์—ˆ์Šต๋‹ˆ๋‹ค.",
                Timestamp = DateTime.Now
            };
            
            _metrics.IncrementFailures();
        }
        catch (Exception ex)
        {
            stopwatch.Stop();
            
            Console.WriteLine($"โŒ ์‹คํŒจ: {url} - {ex.Message}");
            
            _results[url] = new CrawlResult
            {
                Url = url,
                Success = false,
                ErrorMessage = ex.Message,
                ResponseTime = stopwatch.Elapsed,
                Timestamp = DateTime.Now
            };
            
            _metrics.IncrementFailures();
        }
        finally
        {
            _rateLimiter.Release();
        }
    }
    
    // ์ง„ํ–‰ ์ƒํ™ฉ ๋ชจ๋‹ˆํ„ฐ๋ง
    public async Task MonitorProgressAsync(
        Task crawlTask,
        TimeSpan interval)
    {
        while (!crawlTask.IsCompleted)
        {
            await Task.Delay(interval);
            
            var snapshot = _metrics.GetSnapshot();
            Console.WriteLine(
                $"\n๐Ÿ“Š ์ง„ํ–‰ ์ƒํ™ฉ: " +
                $"์„ฑ๊ณต {snapshot.SuccessCount}, " +
                $"์‹คํŒจ {snapshot.FailureCount}, " +
                $"ํ‰๊ท  ์‘๋‹ต์‹œ๊ฐ„ {snapshot.AverageResponseTime.TotalMilliseconds:F0}ms\n"
            );
        }
    }
}

// ํฌ๋กค๋ง ๊ฒฐ๊ณผ
public class CrawlResult
{
    public string Url { get; set; }
    public bool Success { get; set; }
    public int StatusCode { get; set; }
    public int ContentLength { get; set; }
    public TimeSpan ResponseTime { get; set; }
    public string ErrorMessage { get; set; }
    public DateTime Timestamp { get; set; }
}

// ํฌ๋กค๋ง ์š”์•ฝ
public class CrawlSummary
{
    public int TotalUrls { get; set; }
    public int SuccessCount { get; set; }
    public int FailureCount { get; set; }
    public TimeSpan TotalTime { get; set; }
    public List<CrawlResult> Results { get; set; }
    public MetricsSnapshot Metrics { get; set; }
    
    public void PrintSummary()
    {
        Console.WriteLine("\n" + new string('=', 60));
        Console.WriteLine("๐Ÿ“Š ํฌ๋กค๋ง ์š”์•ฝ");
        Console.WriteLine(new string('=', 60));
        Console.WriteLine($"์ด URL: {TotalUrls}");
        Console.WriteLine($"์„ฑ๊ณต: {SuccessCount} ({SuccessCount * 100.0 / TotalUrls:F1}%)");
        Console.WriteLine($"์‹คํŒจ: {FailureCount} ({FailureCount * 100.0 / TotalUrls:F1}%)");
        Console.WriteLine($"์ด ์†Œ์š” ์‹œ๊ฐ„: {TotalTime.TotalSeconds:F2}์ดˆ");
        Console.WriteLine($"ํ‰๊ท  ์‘๋‹ต ์‹œ๊ฐ„: {Metrics.AverageResponseTime.TotalMilliseconds:F0}ms");
        Console.WriteLine($"์ตœ์†Œ ์‘๋‹ต ์‹œ๊ฐ„: {Metrics.MinResponseTime.TotalMilliseconds:F0}ms");
        Console.WriteLine($"์ตœ๋Œ€ ์‘๋‹ต ์‹œ๊ฐ„: {Metrics.MaxResponseTime.TotalMilliseconds:F0}ms");
        Console.WriteLine($"์ฒ˜๋ฆฌ๋Ÿ‰: {TotalUrls / TotalTime.TotalSeconds:F2} URLs/์ดˆ");
        Console.WriteLine(new string('=', 60));
        
        if (FailureCount > 0)
        {
            Console.WriteLine("\nโŒ ์‹คํŒจํ•œ URL:");
            foreach (var result in Results.Where(r => !r.Success))
            {
                Console.WriteLine($"  - {result.Url}: {result.ErrorMessage}");
            }
        }
    }
}

// ์„ฑ๋Šฅ ๋ฉ”ํŠธ๋ฆญ
public class PerformanceMetrics
{
    private int _attempts = 0;
    private int _successes = 0;
    private int _failures = 0;
    private readonly List<TimeSpan> _responseTimes = new();
    private readonly object _lock = new object();
    
    public void IncrementAttempts() => Interlocked.Increment(ref _attempts);
    public void IncrementSuccess() => Interlocked.Increment(ref _successes);
    public void IncrementFailures() => Interlocked.Increment(ref _failures);
    
    public void RecordResponseTime(TimeSpan time)
    {
        lock (_lock)
        {
            _responseTimes.Add(time);
        }
    }
    
    public MetricsSnapshot GetSnapshot()
    {
        lock (_lock)
        {
            return new MetricsSnapshot
            {
                AttemptCount = _attempts,
                SuccessCount = _successes,
                FailureCount = _failures,
                AverageResponseTime = _responseTimes.Any() 
                    ? TimeSpan.FromMilliseconds(_responseTimes.Average(t => t.TotalMilliseconds))
                    : TimeSpan.Zero,
                MinResponseTime = _responseTimes.Any() 
                    ? _responseTimes.Min() 
                    : TimeSpan.Zero,
                MaxResponseTime = _responseTimes.Any() 
                    ? _responseTimes.Max() 
                    : TimeSpan.Zero
            };
        }
    }
}

public class MetricsSnapshot
{
    public int AttemptCount { get; set; }
    public int SuccessCount { get; set; }
    public int FailureCount { get; set; }
    public TimeSpan AverageResponseTime { get; set; }
    public TimeSpan MinResponseTime { get; set; }
    public TimeSpan MaxResponseTime { get; set; }
}

// ์‚ฌ์šฉ ์˜ˆ์‹œ
public class CrawlerDemo
{
    public static async Task Main()
    {
        var urls = new List<string>
        {
            "https://www.google.com",
            "https://www.microsoft.com",
            "https://www.github.com",
            "https://www.stackoverflow.com",
            "https://www.reddit.com",
            "https://www.wikipedia.org",
            "https://www.amazon.com",
            "https://www.twitter.com",
            "https://www.facebook.com",
            "https://www.youtube.com"
        };
        
        var crawler = new WebCrawler(maxConcurrency: 5);
        
        using var cts = new CancellationTokenSource();
        
        // 30์ดˆ ํƒ€์ž„์•„์›ƒ
        cts.CancelAfter(TimeSpan.FromSeconds(30));
        
        // ํฌ๋กค๋ง ์‹œ์ž‘
        var crawlTask = crawler.CrawlAsync(urls, cts.Token);
        
        // ์ง„ํ–‰ ์ƒํ™ฉ ๋ชจ๋‹ˆํ„ฐ๋ง
        var monitorTask = crawler.MonitorProgressAsync(
            crawlTask,
            TimeSpan.FromSeconds(2)
        );
        
        // ์™„๋ฃŒ ๋Œ€๊ธฐ
        var summary = await crawlTask;
        await monitorTask;
        
        // ๊ฒฐ๊ณผ ์ถœ๋ ฅ
        summary.PrintSummary();
    }
}
๐Ÿ’ก ์ด ํฌ๋กค๋Ÿฌ์˜ ํ•ต์‹ฌ ๊ธฐ๋Šฅ: โœ… ๋™์‹œ ์‹คํ–‰ ์ˆ˜ ์ œํ•œ (SemaphoreSlim)
โœ… ์ทจ์†Œ ํ† ํฐ ์ง€์›
โœ… ์‹ค์‹œ๊ฐ„ ์ง„ํ–‰ ์ƒํ™ฉ ๋ชจ๋‹ˆํ„ฐ๋ง
โœ… ์„ฑ๋Šฅ ๋ฉ”ํŠธ๋ฆญ ์ˆ˜์ง‘
โœ… ์—๋Ÿฌ ์ฒ˜๋ฆฌ ๋ฐ ์žฌ์‹œ๋„
โœ… ์Šค๋ ˆ๋“œ ์•ˆ์ „ํ•œ ๊ฒฐ๊ณผ ์ˆ˜์ง‘

์ด๋Ÿฐ ํŒจํ„ด๋“ค์€ ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ๋ฅผ ์ฒ˜๋ฆฌํ•  ๋•Œ๋„ ์œ ์šฉํ•˜๊ฒŒ ์“ฐ์—ฌ!

๐ŸŽ“ ํ•™์Šต ๋ฆฌ์†Œ์Šค์™€ ๋‹ค์Œ ๋‹จ๊ณ„

์—ฌ๊ธฐ๊นŒ์ง€ ์™”๋‹ค๋ฉด ์ •๋ง ๋Œ€๋‹จํ•ด! ๐ŸŽ‰ ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ํ•ต์‹ฌ์„ ๋ชจ๋‘ ๋ฐฐ์› ์–ด. ์ด์ œ ๋” ๊นŠ์ด ๊ณต๋ถ€ํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด ์ด๋Ÿฐ ๊ฒƒ๋“ค์„ ์ถ”์ฒœํ•ด:

๐Ÿ“š ์ถ”์ฒœ ํ•™์Šต ์ž๋ฃŒ

๊ณต์‹ ๋ฌธ์„œ
โ€ข Microsoft Docs - Asynchronous Programming
โ€ข C# Language Specification
โ€ข .NET API Browser

์ฑ…
โ€ข "Concurrency in C# Cookbook" by Stephen Cleary
โ€ข "C# in Depth" by Jon Skeet
โ€ข "Pro Asynchronous Programming with .NET" by Richard Blewett

์˜จ๋ผ์ธ ๊ฐ•์˜
โ€ข Pluralsight - Asynchronous Programming in C#
โ€ข Udemy - Complete C# Masterclass
โ€ข Microsoft Learn - ๋ฌด๋ฃŒ ํ•™์Šต ๊ฒฝ๋กœ

์ปค๋ฎค๋‹ˆํ‹ฐ
โ€ข Stack Overflow - C# ํƒœ๊ทธ
โ€ข Reddit - r/csharp
โ€ข C# Discord ์„œ๋ฒ„

๐Ÿš€ ๋‹ค์Œ ๋‹จ๊ณ„๋กœ ๋‚˜์•„๊ฐ€๊ธฐ

1. ์‹ค์ „ ํ”„๋กœ์ ํŠธ ๋งŒ๋“ค๊ธฐ
๋ฐฐ์šด ๋‚ด์šฉ์„ ์‹ค์ œ ํ”„๋กœ์ ํŠธ์— ์ ์šฉํ•ด๋ด. ์˜ˆ๋ฅผ ๋“ค์–ด:
โ€ข ์›น API ์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ
โ€ข ์‹ค์‹œ๊ฐ„ ์ฑ„ํŒ… ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜
โ€ข ํŒŒ์ผ ์ฒ˜๋ฆฌ ๋„๊ตฌ
โ€ข ๋ฐ์ดํ„ฐ ๋ถ„์„ ํŒŒ์ดํ”„๋ผ์ธ

2. ๊ณ ๊ธ‰ ์ฃผ์ œ ํƒ๊ตฌ
โ€ข Channels์™€ Dataflow
โ€ข Reactive Extensions (Rx.NET)
โ€ข gRPC์™€ ๋น„๋™๊ธฐ ์ŠคํŠธ๋ฆฌ๋ฐ
โ€ข SignalR๋กœ ์‹ค์‹œ๊ฐ„ ํ†ต์‹ 

3. ์„ฑ๋Šฅ ์ตœ์ ํ™”
โ€ข BenchmarkDotNet์œผ๋กœ ๋ฒค์น˜๋งˆํ‚น
โ€ข Memory Profiling
โ€ข Span<T>์™€ Memory<T> ํ™œ์šฉ
โ€ข Zero-allocation ๊ธฐ๋ฒ•

4. ์˜คํ”ˆ์†Œ์Šค ๊ธฐ์—ฌ
โ€ข GitHub์—์„œ C# ํ”„๋กœ์ ํŠธ ์ฐพ๊ธฐ
โ€ข ์ด์Šˆ ํ•ด๊ฒฐํ•˜๊ณ  PR ๋ณด๋‚ด๊ธฐ
โ€ข ์ž์‹ ๋งŒ์˜ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋งŒ๋“ค๊ธฐ

๐Ÿ’ผ ์‹ค๋ฌด ์ ์šฉ ํŒ

ASP.NET Core์—์„œ โ€ข ๋ชจ๋“  ์ปจํŠธ๋กค๋Ÿฌ ์•ก์…˜์„ async๋กœ ๋งŒ๋“ค๊ธฐ
โ€ข Entity Framework Core์˜ ๋น„๋™๊ธฐ ๋ฉ”์„œ๋“œ ์‚ฌ์šฉ
โ€ข IAsyncEnumerable๋กœ ๋Œ€์šฉ๋Ÿ‰ ๋ฐ์ดํ„ฐ ์ŠคํŠธ๋ฆฌ๋ฐ
โ€ข Background Services๋กœ ๋ฐฑ๊ทธ๋ผ์šด๋“œ ์ž‘์—… ์ฒ˜๋ฆฌ

Desktop ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜์—์„œ
โ€ข UI ์Šค๋ ˆ๋“œ ๋ธ”๋กœํ‚น ์ ˆ๋Œ€ ๊ธˆ์ง€
โ€ข Progress ๋ฆฌํฌํŒ…์œผ๋กœ ์‚ฌ์šฉ์ž ๊ฒฝํ—˜ ๊ฐœ์„ 
โ€ข CancellationToken์œผ๋กœ ์ทจ์†Œ ๊ธฐ๋Šฅ ์ œ๊ณต
โ€ข async/await๋กœ ๋ถ€๋“œ๋Ÿฌ์šด UI ์œ ์ง€

๋งˆ์ดํฌ๋กœ์„œ๋น„์Šค์—์„œ
โ€ข HTTP ํด๋ผ์ด์–ธํŠธ ์žฌ์‚ฌ์šฉ (HttpClientFactory)
โ€ข Circuit Breaker ํŒจํ„ด์œผ๋กœ ์žฅ์•  ๊ฒฉ๋ฆฌ
โ€ข Retry ์ •์ฑ…์œผ๋กœ ์ผ์‹œ์  ์˜ค๋ฅ˜ ์ฒ˜๋ฆฌ
โ€ข ๋ถ„์‚ฐ ์ถ”์ ์œผ๋กœ ์„ฑ๋Šฅ ๋ชจ๋‹ˆํ„ฐ๋ง

๐ŸŽฏ ๋งˆ๋ฌด๋ฆฌํ•˜๋ฉฐ

์™€! ์ •๋ง ๊ธด ์—ฌ์ •์ด์—ˆ์ง€? ๐Ÿ˜… ํ•˜์ง€๋งŒ ์ด์ œ ๋„ˆ๋Š” C# ๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์˜ ๊ฑฐ์˜ ๋ชจ๋“  ๊ฒƒ์„ ์•Œ๊ฒŒ ๋์–ด!

async/await์™€ Task๋Š” ๋‹จ์ˆœํ•œ ํ‚ค์›Œ๋“œ๊ฐ€ ์•„๋‹ˆ์•ผ. ์ด๊ฒƒ๋“ค์€ ํ˜„๋Œ€ ์• ํ”Œ๋ฆฌ์ผ€์ด์…˜ ๊ฐœ๋ฐœ์˜ ํ•„์ˆ˜ ๋„๊ตฌ์ด๊ณ , ์‚ฌ์šฉ์ž์—๊ฒŒ ๋” ๋‚˜์€ ๊ฒฝํ—˜์„ ์ œ๊ณตํ•˜๋Š” ํ•ต์‹ฌ ๊ธฐ์ˆ ์ด์ง€. ๐Ÿš€

๊ธฐ์–ตํ•ด์•ผ ํ•  ํ•ต์‹ฌ ํฌ์ธํŠธ๋“ค์„ ์ •๋ฆฌํ•ด๋ณผ๊ฒŒ:

๐ŸŽฏ ํ•ต์‹ฌ ์š”์•ฝ

1. ๊ธฐ๋ณธ ์›์น™
โœ… async/await๋กœ ๋น„๋™๊ธฐ ์ฝ”๋“œ๋ฅผ ๋™๊ธฐ ์ฝ”๋“œ์ฒ˜๋Ÿผ ์ž‘์„ฑ
โœ… Task๋Š” ๋น„๋™๊ธฐ ์ž‘์—…์„ ๋‚˜ํƒ€๋‚ด๋Š” ๊ฐ์ฒด
โœ… UI ์Šค๋ ˆ๋“œ๋ฅผ ์ ˆ๋Œ€ ๋ธ”๋กœํ‚นํ•˜์ง€ ๋ง ๊ฒƒ

2. ์„ฑ๋Šฅ ์ตœ์ ํ™”
โœ… Task.WhenAll๋กœ ๋ณ‘๋ ฌ ์ฒ˜๋ฆฌ
โœ… ValueTask๋กœ ๋ฉ”๋ชจ๋ฆฌ ์ตœ์ ํ™”
โœ… ConfigureAwait(false)๋กœ ๋ถˆํ•„์š”ํ•œ ์ปจํ…์ŠคํŠธ ์ „ํ™˜ ์ œ๊ฑฐ
โœ… IAsyncEnumerable๋กœ ์ŠคํŠธ๋ฆฌ๋ฐ ์ฒ˜๋ฆฌ

3. ์•ˆ์ •์„ฑ
โœ… CancellationToken์œผ๋กœ ์ทจ์†Œ ์ง€์›
โœ… ์ ์ ˆํ•œ ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
โœ… Retry์™€ Circuit Breaker ํŒจํ„ด
โœ… ๋™์‹œ์„ฑ ์ œ์–ด (SemaphoreSlim)

4. ํ”ผํ•ด์•ผ ํ•  ๊ฒƒ๋“ค
โŒ async void (์ด๋ฒคํŠธ ํ•ธ๋“ค๋Ÿฌ ์ œ์™ธ)
โŒ .Result๋‚˜ .Wait() ํ˜ธ์ถœ
โŒ ๋™๊ธฐ ๋ฉ”์„œ๋“œ๋ฅผ Task.Run์œผ๋กœ ๊ฐ์‹ธ๊ธฐ
โŒ ๋ถˆํ•„์š”ํ•œ async/await

๋น„๋™๊ธฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์€ ์ฒ˜์Œ์—๋Š” ์–ด๋ ต๊ฒŒ ๋А๊ปด์งˆ ์ˆ˜ ์žˆ์–ด. ํ•˜์ง€๋งŒ ๊ณ„์† ์—ฐ์Šตํ•˜๋‹ค ๋ณด๋ฉด ์ž์—ฐ์Šค๋Ÿฝ๊ฒŒ ์†์— ์ต๊ฒŒ ๋ผ. ๋งˆ์น˜ ์ž์ „๊ฑฐ ํƒ€๋Š” ๊ฒƒ์ฒ˜๋Ÿผ ๋ง์ด์•ผ! ๐Ÿšดโ€โ™‚๏ธ

์‹ค์ˆ˜๋ฅผ ๋‘๋ ค์›Œํ•˜์ง€ ๋งˆ. ๋ชจ๋“  ๊ฐœ๋ฐœ์ž๊ฐ€ ์ฒ˜์Œ์—๋Š” ๋ฐ๋“œ๋ฝ๋„ ๋งŒ๋“ค๊ณ , ์˜ˆ์™ธ๋„ ๋†“์น˜๊ณ , ์„ฑ๋Šฅ ๋ฌธ์ œ๋„ ๊ฒช์–ด. ์ค‘์š”ํ•œ ๊ฑด ๊ทธ๋Ÿฐ ๊ฒฝํ—˜์—์„œ ๋ฐฐ์šฐ๋Š” ๊ฑฐ์•ผ. ๐Ÿ’ช

์ด์ œ ๋„ˆ๋งŒ์˜ ํ”„๋กœ์ ํŠธ๋ฅผ ๋งŒ๋“ค์–ด๋ด! ๋ฐฐ์šด ๋‚ด์šฉ์„ ์‹ค์ „์— ์ ์šฉํ•˜๋ฉด์„œ ์ง„์งœ ์‹ค๋ ฅ์ด ๋Š˜์–ด๋‚  ๊ฑฐ์•ผ. ๊ทธ๋ฆฌ๊ณ  ๋ง‰ํžˆ๋Š” ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฉด ๊ณต์‹ ๋ฌธ์„œ๋ฅผ ์ฐพ์•„๋ณด๊ณ , ์ปค๋ฎค๋‹ˆํ‹ฐ์— ์งˆ๋ฌธํ•˜๊ณ , ๋‹ค๋ฅธ ์‚ฌ๋žŒ๋“ค์˜ ์ฝ”๋“œ๋„ ์ฝ์–ด๋ด.

ํ˜น์‹œ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๊ด€๋ จํ•ด์„œ ๋„์›€์ด ํ•„์š”ํ•˜๊ฑฐ๋‚˜, ๋ฉ˜ํ† ๋ง์„ ๋ฐ›๊ณ  ์‹ถ๋‹ค๋ฉด ์žฌ๋Šฅ๋„ท ๊ฐ™์€ ํ”Œ๋žซํผ์—์„œ ์ „๋ฌธ๊ฐ€๋“ค์˜ ๋„์›€์„ ๋ฐ›๋Š” ๊ฒƒ๋„ ์ข‹์€ ๋ฐฉ๋ฒ•์ด์•ผ! ๋•Œ๋กœ๋Š” ๊ฒฝํ—˜ ๋งŽ์€ ๊ฐœ๋ฐœ์ž์˜ ์กฐ์–ธ ํ•œ๋งˆ๋””๊ฐ€ ๋ฉฐ์น ๊ฐ„์˜ ๊ณ ๋ฏผ์„ ํ•ด๊ฒฐํ•ด์ฃผ๊ธฐ๋„ ํ•˜๊ฑฐ๋“ . ๐Ÿ˜Š

์ž, ์ด์ œ ์ฝ”๋”ฉ์„ ์‹œ์ž‘ํ•  ์‹œ๊ฐ„์ด์•ผ! ํ™”์ดํŒ…! ๐ŸŽ‰

๐ŸŒŸ Happy Async Coding! ๐ŸŒŸ

"The best way to predict the future is to implement it asynchronously."
- ์ต๋ช…์˜ C# ๊ฐœ๋ฐœ์ž

๋Œ“๊ธ€ ์ž‘์„ฑ

์ด ๊ธ€์— ๋Œ€ํ•œ ์—ฌ๋Ÿฌ๋ถ„์˜ ์ƒ๊ฐ์„ ๋“ค๋ ค์ฃผ์„ธ์š”

๋Œ“๊ธ€ 0
๋Œ“๊ธ€์„ ๋ถˆ๋Ÿฌ์˜ค๋Š” ์ค‘์ž…๋‹ˆ๋‹ค.

์•„์ง ๋Œ“๊ธ€์ด ์—†์Šต๋‹ˆ๋‹ค.