Async Basics

🚀 C# Async Programming: The Magic of Doing Many Things at Once

Imagine you’re at a restaurant. You order food, but instead of standing frozen at the counter waiting, you sit down, chat with friends, check your phone, and when the food is ready—someone calls your name. That’s async programming!

🎯 What is Async Programming?

Think of your computer like a super-fast chef. Without async, this chef can only do ONE thing at a time:

• Start boiling water → Wait… → Water boils → Start chopping → Wait… → Done chopping

With async? The chef starts boiling water, immediately starts chopping while waiting, checks on both, and gets everything done faster!

The Big Idea: Instead of waiting and doing nothing, we can start a task and come back when it’s ready.

📖 The Story: Meet Your New Best Friends

Let me introduce you to three heroes who make async magic happen:

1️⃣ Async and Await Basics

The Simplest Example

// Without async - BLOCKED!
string GetData() {
    Thread.Sleep(3000); // Frozen for 3 seconds
    return "Data!";
}

// With async - FREE to do other things!
async Task<string> GetDataAsync() {
    await Task.Delay(3000); // Waits, but doesn't block
    return "Data!";
}

🎭 The Story

Imagine you’re ordering a pizza:

Without async:

1. You call the pizza shop
2. You stand at your phone… frozen… waiting…
3. Pizza arrives after 30 minutes
4. Only NOW can you do anything else

With async:

1. You call the pizza shop → async
2. “I’ll wait for the pizza” → await
3. While waiting, you watch TV, do laundry, play games
4. Doorbell rings → Your await finishes!

✅ Key Rules

// Rule 1: Use 'async' in method signature
async Task DoSomethingAsync()

// Rule 2: Use 'await' before async operations
await SomeAsyncMethod();

// Rule 3: Return Task (or Task<T> for values)
async Task<int> GetNumberAsync()

2️⃣ Task and Task<T>

What’s a Task?

A Task is like a ticket at a deli counter. You get the ticket (Task), do other shopping, and come back when your number is called.

// Task = "I'll do something, but no result"
Task task = DoWorkAsync();

// Task<T> = "I'll do something AND give you a result"
Task<int> task = CalculateAsync();
int result = await task; // Get the result!

🎪 Visual Flow

graph TD
    A["Start Task"] --> B{Task Running}
    B --> C[You're Free!<br/>Do Other Things]
    B --> D["Task Completes"]
    D --> E["Result Ready"]
    C --> E
    E --> F["Continue with Result"]

Creating Tasks

// Method 1: Async method (most common)
async Task<string> FetchUserAsync() {
    await Task.Delay(1000);
    return "John";
}

// Method 2: Task.Run for CPU work
Task<int> result = Task.Run(() => {
    // Heavy calculation
    return 42;
});

// Method 3: Task.FromResult (already done!)
Task<string> instant = Task.FromResult("Ready!");

3️⃣ ValueTask: The Speedy Sibling

Why ValueTask?

Task creates a new object every time (costs memory). ValueTask is smarter—if the result is already ready, no extra object needed!

// Good for caching scenarios
async ValueTask<int> GetCachedValueAsync() {
    if (_cache.TryGetValue("key", out int val))
        return val; // No allocation! Super fast!

    return await FetchFromDatabaseAsync();
}

🎯 When to Use What?

⚠️ ValueTask Warning

// ❌ WRONG - Can only await once!
ValueTask<int> vt = GetValueAsync();
int a = await vt;
int b = await vt; // CRASH!

// ✅ RIGHT - One await only
int result = await GetValueAsync();

4️⃣ Async Return Types

The Complete Family

// 1. Task - No return value
async Task SaveAsync() {
    await db.SaveChangesAsync();
}

// 2. Task<T> - Returns a value
async Task<string> GetNameAsync() {
    return await FetchNameAsync();
}

// 3. ValueTask<T> - Optimized returns
async ValueTask<int> GetCountAsync() {
    return _cachedCount ?? await CountAsync();
}

// 4. void - ONLY for event handlers!
async void Button_Click(object s, EventArgs e) {
    await DoWorkAsync();
}

// 5. IAsyncEnumerable<T> - Stream of values
async IAsyncEnumerable<int> GetNumbersAsync() {
    for (int i = 0; i < 10; i++) {
        await Task.Delay(100);
        yield return i;
    }
}

🚨 The async void Danger

// ❌ NEVER do this (except event handlers)
async void BadMethod() {
    await Task.Delay(1000);
    throw new Exception(); // Crashes app! Unhandled!
}

// ✅ Always prefer Task
async Task GoodMethod() {
    await Task.Delay(1000);
    throw new Exception(); // Can be caught!
}

5️⃣ Async Streams (IAsyncEnumerable)

The Story

Imagine a news ticker. Instead of waiting for ALL news to load, each headline appears as soon as it’s ready. That’s async streams!

// Producer: Sends items one by one
async IAsyncEnumerable<string> GetHeadlinesAsync() {
    string[] news = { "Breaking!", "Sports", "Weather" };
    foreach (var item in news) {
        await Task.Delay(500); // Simulate network
        yield return item;
    }
}

// Consumer: Receives items one by one
await foreach (var headline in GetHeadlinesAsync()) {
    Console.WriteLine(headline);
    // Each prints 500ms apart!
}

🎬 How It Flows

graph TD
    A["Start Stream"] --> B["Yield Item 1"]
    B --> C["Process Item 1"]
    C --> D["Yield Item 2"]
    D --> E["Process Item 2"]
    E --> F["Yield Item 3"]
    F --> G["Process Item 3"]
    G --> H["Stream Complete"]

6️⃣ Cancellation Tokens: The Stop Button

The Story

You start downloading a huge file. After 5 minutes, you realize it’s the wrong file. Without cancellation? You wait forever. With CancellationToken? You hit STOP!

// Create a cancellation source
var cts = new CancellationTokenSource();

// Start the operation
Task task = DownloadAsync(cts.Token);

// Changed your mind? CANCEL!
cts.Cancel();

Full Example

async Task DownloadFileAsync(CancellationToken ct) {
    for (int i = 0; i < 100; i++) {
        // Check if cancelled
        ct.ThrowIfCancellationRequested();

        await Task.Delay(100, ct); // Also respects cancel
        Console.WriteLine(quot;Downloaded {i}%");
    }
}

// Usage
var cts = new CancellationTokenSource();
cts.CancelAfter(3000); // Auto-cancel after 3 seconds

try {
    await DownloadFileAsync(cts.Token);
}
catch (OperationCanceledException) {
    Console.WriteLine("Download was cancelled!");
}

🎮 Cancellation Patterns

7️⃣ Task Combinators: Juggling Multiple Tasks

WhenAll: Wait for EVERYONE

Like waiting for all friends to arrive before starting a party.

Task<string> getName = GetNameAsync();
Task<int> getAge = GetAgeAsync();
Task<string> getCity = GetCityAsync();

// All three run at the SAME TIME!
await Task.WhenAll(getName, getAge, getCity);

// Now all results are ready
string name = await getName;
int age = await getAge;
string city = await getCity;

WhenAny: First One Wins!

Like a race—whoever finishes first, we go with them.

Task<string> server1 = FetchFromServer1Async();
Task<string> server2 = FetchFromServer2Async();
Task<string> server3 = FetchFromServer3Async();

// Whichever server responds first!
Task<string> winner = await Task.WhenAny(
    server1, server2, server3
);
string result = await winner;

🎯 Combinator Cheat Sheet

graph TD
    A["Task Combinators"] --> B["WhenAll"]
    A --> C["WhenAny"]
    B --> D["Wait for ALL tasks<br/>Returns when LAST completes"]
    C --> E["Wait for ANY task<br/>Returns when FIRST completes"]

Practical Example: Parallel API Calls

async Task<UserProfile> GetFullProfileAsync(int userId) {
    // Start all calls at once (parallel!)
    var userTask = GetUserAsync(userId);
    var postsTask = GetPostsAsync(userId);
    var friendsTask = GetFriendsAsync(userId);

    // Wait for all to complete
    await Task.WhenAll(userTask, postsTask, friendsTask);

    return new UserProfile {
        User = await userTask,
        Posts = await postsTask,
        Friends = await friendsTask
    };
}

🎓 Summary: Your Async Toolkit

🚀 You Did It!

You now understand async programming in C#! Remember:

1. async/await = Don’t block, stay responsive
2. Task = A promise of future work
3. ValueTask = When you need speed
4. Cancellation = Always have a stop button
5. Combinators = Juggle multiple tasks like a pro

Go forth and write responsive, efficient, beautiful async code! 🎉