Bits of .NET

☠️ The Silent Killer: Application.Hang

System.Threading.Tasks.Task
Status: WaitingForActivation
No exceptions thrown
No error logs
Just... frozen forever

Welcome to the deadlock nightmare. It’s 3 AM. Your app is frozen. Users are screaming. And you have NO IDEA where the problem is.

☠️ DEADLOCK CODE (Don’t Copy This!)

// The code that will haunt your dreams
public class UserController : Controller
{
    public ActionResult Index()
    {
        // ASP.NET has a SynchronizationContext
        // This thread is the "UI thread"
        
        var users = GetUsersAsync().Result;  // 💀 DEADLOCK!
        // or
        var users = GetUsersAsync().GetAwaiter().GetResult();  // 💀 STILL DEADLOCK!
        
        return View(users);
    }

    public async Task<List> GetUsersAsync()
    {
        await Task.Delay(1000);  // Simulates DB call
        return new List();
    }
}

// What happens:
// 1. Main thread calls GetUsersAsync().Result (BLOCKS main thread)
// 2. GetUsersAsync starts, hits await, releases thread
// 3. await tries to resume on main thread (SynchronizationContext)
// 4. But main thread is BLOCKED waiting for Result
// 5. Neither can proceed = DEADLOCK
// 6. Application hangs forever

✅ THE FIX: Async All The Way

// The correct way
public async Task Index()
{
    var users = await GetUsersAsync();  // ✅ No blocking!
    return View(users);
}

public async Task<List> GetUsersAsync()
{
    await Task.Delay(1000);
    return new List();
}

// Why it works:
// 1. Main thread calls GetUsersAsync() with await
// 2. GetUsersAsync starts, hits await
// 3. Main thread is RELEASED (not blocked)
// 4. When done, resumes on available thread
// 5. No deadlock possible

☠️ The Deadlock Hall of Shame

// ❌ DEADLOCK: Using .Result
var data = GetDataAsync().Result;

// ❌ DEADLOCK: Using .Wait()
GetDataAsync().Wait();

// ❌ DEADLOCK: Using .GetAwaiter().GetResult()
var data = GetDataAsync().GetAwaiter().GetResult();

// ❌ DEADLOCK: Task.Run with blocking
Task.Run(() => GetDataAsync().Result);

// ✅ CORRECT: await all the way
var data = await GetDataAsync();

// ✅ CORRECT: In console apps (no SyncContext)
var data = GetDataAsync().GetAwaiter().GetResult();  // OK in console

🛡️ Rules to Never Deadlock

1. Async all the way: If you use async anywhere, use it everywhere in the call chain
2. Never use .Result or .Wait(): In ASP.NET/WPF (except Main method of console apps)
3. ConfigureAwait(false) in libraries: Prevents capturing SynchronizationContext
4. Don’t mix sync and async: Pick one pattern and stick with it
5. Test on real environment: Deadlocks often don’t appear in unit tests

🔧 Library Code Pattern

// In library code (not UI/API code)
public async Task GetDataAsync()
{
    // Use ConfigureAwait(false) to avoid capturing SyncContext
    var result = await httpClient.GetAsync(url).ConfigureAwait(false);
    var content = await result.Content.ReadAsStringAsync().ConfigureAwait(false);
    return JsonSerializer.Deserialize(content);
}

// Why ConfigureAwait(false)?
// - Doesn't try to resume on original thread
// - Resumes on thread pool thread
// - Prevents deadlock if caller uses .Result
// - Slightly better performance

// When NOT to use ConfigureAwait(false):
// - UI code (needs to update UI on UI thread)
// - ASP.NET controllers (usually fine either way)

⚠️ How to Debug a Deadlock

// 1. Attach debugger to frozen process
// 2. Debug → Windows → Threads
// 3. Look for threads with status "WaitingForActivation"
// 4. Check call stack - look for .Result or .Wait()
// 5. Follow async chain back to source

// Prevention: Enable warnings

  CS1998


// This catches: async methods without await