C# Advanced - Deep Dive: How Everything Connects

1. The Mental Model: One Thread, Many Jobs

Think of your app as Kunal's pizza shop. One kitchen. 1000 orders. Old way: hire 1000 chefs, each waits 30 mins for oven. Kitchen dies. New way: 5 chefs, each starts oven, goes to next order. When bell rings, finish that pizza. That's async.

// The 5 concepts in one line:
List<Order> orders = await File.ReadAllLinesAsync("orders.txt")  // File I/O + Async + Generics
    .ContinueWith(t => t.Result                      // Task continuation = Delegate
    .Select(line => ParseOrder(line))                // LINQ + Lambda = Delegate
    .Where(o => o.IsPaid)                            // LINQ + Delegate
    .ToList());                                      // Generics: List<Order>

2. Connection 1: Delegates Are The Engine of LINQ

LINQ is just syntax sugar over delegates. Where takes Func<T,bool>. That's a delegate.

// This LINQ:
var adults = users.Where(u => u.Age > 18);

// Compiles to this:
Func<User,bool> predicate = u => u.Age > 18; // Delegate
var adults = Enumerable.Where(users, predicate); // Method takes delegate

Why it matters: Prerna writes users.Where(u => u.Name.StartsWith("K")). Compiler creates delegate instance. If she puts that in a loop, she creates 1000 delegates. Slow. Hoist it: Func<User,bool> filter = u => ... outside loop.

3. Connection 2: Generics Make Async Possible

Task<T> is generic. Without generics, you'd need IntTask, StringTask, PizzaTask. Nightmare.

public async Task<Pizza> BakeAsync() { // Task<T> = generic
    await Task.Delay(1000);
    return new Pizza();
}

Task<Pizza> t = BakeAsync(); // Compiler knows t.Result is Pizza. Type safe.

Deep insight: async state machine stores locals as fields. If method has int x, string y, compiler generates class StateMachine<T> { int x; string y; Task<T> task; }. Generics let one state machine code work for any return type.

4. Connection 3: Async + File I/O = Scale

Web server gets 10,000 file reads. Sync way: 10,000 threads blocked on disk. Each thread = 1MB stack. RAM dead.

Rule Kaushal learned: I/O = always async. CPU = stay sync unless you parallelize. await releases thread during disk wait. Thread pool handles other requests. That's how Netflix serves millions.

5. Connection 4: Events + Async = Reactive Systems

Combine them for real-time apps. Sanju builds stock ticker:

class PriceFeed {
    public event Func<Price, Task> OnPrice; // Async event: delegate returns Task
    
    public async Task RaiseAsync(Price p) {
        if (OnPrice == null) return;
        var tasks = OnPrice.GetInvocationList()
            .Cast<Func<Price, Task>>()
            .Select(d => d(p)); // All handlers run in parallel
        await Task.WhenAll(tasks);
    }
}

// Subscriber:
feed.OnPrice += async price => {
    await db.SaveAsync(price); // Non-blocking handler
    await File.AppendAllTextAsync("log.txt", price.ToString());
};

Pattern: Events + async delegates + Task.WhenAll = fan-out without blocking. Core of SignalR, gRPC streaming.

6. Performance: The Full Picture

7. Memory: The State Machine Truth

Every async method becomes a class. Every await adds a state. Every List<T> allocates array. Every LINQ query allocates enumerator.

async Task<int> Calc() {
    int a = GetA();      // State 0: field int a
    int b = await GetB(); // State 1: await point
    return a + b;         // State 2: resume here
}
// Compiler generates: class CalcStateMachine { int a; int b; int state; Task<int> builder; }

Kiaan's rule: Async isn't free. ~100 bytes per await. Don't make every method async. Only I/O boundaries. CPU loops stay sync.

You've Completed C# Advanced

Kunal started with callbacks. Prerna learned LINQ. Kaushal beat deadlocks. Sanju stopped boxing. Karan scaled to 10k users. Kashvee shipped to prod. You're them now.

Next Path: 1. Build a real API using these 5. 2. Study System Design: how async scales to millions. 3. Contribute to OSS: most bugs are in these topics.