What is a deadlock and how can async/await cause it?

A deadlock occurs when two or more operations are waiting for each other to complete, causing the application to freeze indefinitely.

Common async/await deadlock scenario: Blocking on async code (using .Result or .Wait()) in a context with a synchronization context (like UI applications).

Example:

// DEADLOCK EXAMPLES

// Example 1: Classic UI Deadlock
public class UIDeadlockExample
{
    // THIS CAUSES A DEADLOCK IN UI APPLICATIONS
    public void ButtonClick()
    {
        // UI thread blocks here waiting for result
        var result = GetDataAsync().Result;
        
        // Never reaches here - DEADLOCK!
        Console.WriteLine(result);
    }
    
    private async Task GetDataAsync()
    {
        // Simulates async operation (HTTP call, database query, etc.)
        await Task.Delay(1000);
        
        // Tries to resume on UI thread, but UI thread is blocked waiting!
        // DEADLOCK!
        return "Data";
    }
    
    // Explanation:
    // 1. UI thread calls GetDataAsync().Result and blocks
    // 2. GetDataAsync starts and awaits Task.Delay
    // 3. When Task.Delay completes, it tries to resume on UI thread
    // 4. But UI thread is blocked waiting for the result
    // 5. DEADLOCK - each is waiting for the other
}

// Example 2: ASP.NET Deadlock (pre-.NET Core)
public class AspNetDeadlockExample
{
    // THIS CAUSES A DEADLOCK IN ASP.NET (not ASP.NET Core)
    public ActionResult Index()
    {
        // ASP.NET request thread blocks here
        var data = GetDataAsync().Result;
        
        return View(data);
    }
    
    private async Task GetDataAsync()
    {
        await Task.Delay(1000);
        // Tries to resume on ASP.NET synchronization context
        return "Data";
    }
}

// SOLUTIONS TO DEADLOCKS

// Solution 1: Use async all the way (BEST)
public class AsyncAllTheWayExample
{
    // Proper async implementation
    public async Task ButtonClickAsync()
    {
        // Don't block - await instead
        var result = await GetDataAsync();
        Console.WriteLine(result);
    }
    
    private async Task GetDataAsync()
    {
        await Task.Delay(1000);
        return "Data";
    }
}

// Solution 2: Use ConfigureAwait(false) in library code
public class ConfigureAwaitSolution
{
    public void ButtonClick()
    {
        // Still not ideal, but won't deadlock
        var result = GetDataAsync().Result;
        Console.WriteLine(result);
    }
    
    private async Task GetDataAsync()
    {
        // ConfigureAwait(false) prevents capturing sync context
        await Task.Delay(1000).ConfigureAwait(false);
        
        // Won't try to resume on UI thread
        return "Data";
    }
}

// Solution 3: Run on thread pool
public class ThreadPoolSolution
{
    public void ButtonClick()
    {
        // Move work to thread pool
        Task.Run(async () =>
        {
            var result = await GetDataAsync();
            
            // Need to marshal back to UI thread for UI updates
            Application.Current.Dispatcher.Invoke(() =>
            {
                Console.WriteLine(result);
            });
        });
    }
    
    private async Task GetDataAsync()
    {
        await Task.Delay(1000);
        return "Data";
    }
}

// COMPLEX DEADLOCK SCENARIOS

// Scenario 1: Nested async calls
public class NestedDeadlockExample
{
    public void ProcessData()
    {
        // Blocking on first async method
        var result = FirstMethodAsync().Result;
    }
    
    private async Task FirstMethodAsync()
    {
        // This method awaits another async method
        var data = await SecondMethodAsync();
        return data.ToUpper();
    }
    
    private async Task SecondMethodAsync()
    {
        await Task.Delay(1000);
        // Deadlock occurs here trying to resume
        return "data";
    }
}

// Scenario 2: Multiple blocking calls
public class MultipleBlockingExample
{
    public void ProcessMultiple()
    {
        // Each of these can cause a deadlock
        var result1 = GetData1Async().Result;
        var result2 = GetData2Async().Result;
        var result3 = GetData3Async().Result;
    }
    
    private async Task GetData1Async()
    {
        await Task.Delay(100);
        return "Data1";
    }
    
    private async Task GetData2Async()
    {
        await Task.Delay(100);
        return "Data2";
    }
    
    private async Task GetData3Async()
    {
        await Task.Delay(100);
        return "Data3";
    }
}

// CORRECT PATTERNS

// Pattern 1: Async all the way up
public class CorrectAsyncPattern
{
    // Controller/UI method is async
    public async Task ProcessDataAsync()
    {
        var result1 = await GetData1Async();
        var result2 = await GetData2Async();
        var result3 = await GetData3Async();
        
        Console.WriteLine($"{result1}, {result2}, {result3}");
    }
    
    private async Task GetData1Async()
    {
        await Task.Delay(100);
        return "Data1";
    }
    
    private async Task GetData2Async()
    {
        await Task.Delay(100);
        return "Data2";
    }
    
    private async Task GetData3Async()
    {
        await Task.Delay(100);
        return "Data3";
    }
}

// Pattern 2: Library code with ConfigureAwait
public class LibraryCodePattern
{
    public async Task GetUserDataAsync(int userId)
    {
        // All awaits use ConfigureAwait(false)
        var user = await FetchUserAsync(userId).ConfigureAwait(false);
        var orders = await FetchOrdersAsync(userId).ConfigureAwait(false);
        var preferences = await FetchPreferencesAsync(userId).ConfigureAwait(false);
        
        return new UserData
        {
            User = user,
            Orders = orders,
            Preferences = preferences
        };
    }
    
    private async Task FetchUserAsync(int id)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return new User { Id = id, Name = "John" };
    }
    
    private async Task<List> FetchOrdersAsync(int userId)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return new List();
    }
    
    private async Task FetchPreferencesAsync(int userId)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return new Preferences();
    }
    
    public class User { public int Id { get; set; } public string Name { get; set; } }
    public class Order { }
    public class Preferences { }
    public class UserData
    {
        public User User { get; set; }
        public List Orders { get; set; }
        public Preferences Preferences { get; set; }
    }
}

// Detecting deadlocks
public class DeadlockDetection
{
    public void DetectDeadlock()
    {
        try
        {
            // Set a timeout to detect potential deadlock
            var task = GetDataAsync();
            
            if (!task.Wait(TimeSpan.FromSeconds(5)))
            {
                Console.WriteLine("Potential deadlock detected!");
            }
        }
        catch (AggregateException ex)
        {
            Console.WriteLine($"Error: {ex.InnerException?.Message}");
        }
    }
    
    private async Task GetDataAsync()
    {
        await Task.Delay(1000);
        return "Data";
    }
}

Key Takeaways:

1. Never block on async code - Don't use .Result or .Wait() in UI or ASP.NET contexts
2. Async all the way - Make your methods async from top to bottom
3. Use ConfigureAwait(false) in library code
4. ASP.NET Core is safer - It doesn't have a synchronization context, reducing deadlock risk
5. Be careful with Task.WaitAll() - Same issues as .Result