Asynchronous Programming

Task.WhenAll() waits for all tasks in a collection to complete before continuing. It returns a task that completes when all input tasks have completed.

Key characteristics of Task.WhenAll():

• Waits for ALL tasks to finish
• Returns an array of results (if tasks return values)
• If any task throws an exception, the returned task will be faulted
• All exceptions are aggregated in an AggregateException
• Useful for parallel execution where you need all results

// Example: Download multiple files concurrently
var task1 = DownloadFileAsync("file1.txt");
var task2 = DownloadFileAsync("file2.txt");
var task3 = DownloadFileAsync("file3.txt");

// Wait for all downloads to complete
await Task.WhenAll(task1, task2, task3);
Console.WriteLine("All files downloaded");

Task.WhenAny() returns as soon as ANY one of the tasks completes. It returns a task that represents the first completed task.

Key characteristics of Task.WhenAny():

• Returns when the FIRST task completes
• Returns the completed task itself (not the result)
• Useful for timeout scenarios or racing multiple operations
• Other tasks continue running in the background

// Example: Implement timeout pattern
var dataTask = FetchDataAsync();
var timeoutTask = Task.Delay(TimeSpan.FromSeconds(5));

var completedTask = await Task.WhenAny(dataTask, timeoutTask);

if (completedTask == timeoutTask)
{
    throw new TimeoutException("Operation timed out");
}

var result = await dataTask;

ValueTask is a value type (struct) that represents an asynchronous operation, introduced to reduce heap allocations in high-performance scenarios.

Key differences from Task:

Task:

• Reference type (class) - allocated on the heap
• Can be awaited multiple times
• Can be cached and reused safely
• Slightly more overhead due to allocation

ValueTask:

• Value type (struct) - can be allocated on the stack
• Should only be awaited once
• More efficient when the operation completes synchronously
• Less garbage collection pressure

When to use ValueTask:

Use ValueTask when:

1. The operation frequently completes synchronously (e.g., cached results)
2. Performance is critical and you want to avoid allocations
3. You're building high-throughput libraries or APIs
4. The result is only awaited once

// Good use case: Cache-backed operation
public async ValueTask GetUserAsync(int userId)
{
    // Check cache first - often completes synchronously
    if (_cache.TryGetValue(userId, out var user))
    {
        return user; // No Task allocation needed
    }
    
    // Cache miss - fetch from database
    user = await _database.GetUserAsync(userId);
    _cache.Add(userId, user);
    return user;
}

When to use Task:

Use Task when:

1. The operation is always asynchronous
2. You need to await the result multiple times
3. You need to store the task for later use
4. Working with public APIs where simplicity matters

// Task is better here - result may be awaited multiple times
public Task FetchDataAsync()
{
    return _httpClient.GetStringAsync("https://api.example.com/data");
}

Important rules for ValueTask:

• Only await a ValueTask once
• Don't store ValueTask in fields or properties
• Convert to Task if you need multiple awaits: valueTask.AsTask()

Exception handling in async methods uses try-catch blocks, but with important considerations for how exceptions are propagated.

Basic exception handling:

public async Task ProcessDataAsync()
{
    try
    {
        var data = await FetchDataAsync();
        await SaveDataAsync(data);
    }
    catch (HttpRequestException ex)
    {
        // Handle network errors
        _logger.LogError(ex, "Network error occurred");
        throw;
    }
    catch (Exception ex)
    {
        // Handle other errors
        _logger.LogError(ex, "Unexpected error");
        throw;
    }
    finally
    {
        // Cleanup code always runs
        _logger.LogInformation("Processing completed");
    }
}

Handling exceptions with Task.WhenAll():

When using Task.WhenAll(), only the first exception is thrown. To get all exceptions:

public async Task ProcessMultipleAsync()
{
    var tasks = new[]
    {
        ProcessItem1Async(),
        ProcessItem2Async(),
        ProcessItem3Async()
    };
    
    try
    {
        await Task.WhenAll(tasks);
    }
    catch (Exception ex)
    {
        // Only first exception is caught here
        _logger.LogError(ex, "At least one task failed");
        
        // To get ALL exceptions:
        foreach (var task in tasks)
        {
            if (task.IsFaulted)
            {
                foreach (var exception in task.Exception.InnerExceptions)
                {
                    _logger.LogError(exception, "Task exception");
                }
            }
        }
    }
}

Fire-and-forget pattern (dangerous but sometimes necessary):

// BAD: Exception will crash the application
public void StartBackgroundWork()
{
    _ = DoWorkAsync(); // Fire and forget - DON'T DO THIS
}

// GOOD: Properly handled fire-and-forget
public void StartBackgroundWork()
{
    _ = SafeFireAndForgetAsync(DoWorkAsync());
}

private async Task SafeFireAndForgetAsync(Task task)
{
    try
    {
        await task;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Background task failed");
    }
}

Exception handling with ConfigureAwait:

public async Task ProcessAsync()
{
    try
    {
        // ConfigureAwait doesn't affect exception handling
        var result = await FetchDataAsync().ConfigureAwait(false);
        await SaveAsync(result).ConfigureAwait(false);
    }
    catch (Exception ex)
    {
        // Exceptions are still caught normally
        _logger.LogError(ex, "Error in processing");
    }
}

Key principles:

• Always await async methods to catch exceptions
• Use try-catch around await statements
• Log exceptions before rethrowing
• Be aware of AggregateException with Task.WhenAll()
• Never ignore exceptions in fire-and-forget scenarios

Synchronous Programming:

In synchronous programming, operations execute sequentially. Each operation must complete before the next one begins, blocking the thread until finished.

Characteristics:

• Sequential execution
• Thread blocking
• Simple and predictable
• Can lead to poor responsiveness
• Easier to reason about

// Synchronous example
public void ProcessData()
{
    var data = FetchData(); // Blocks thread until complete
    var processed = TransformData(data); // Waits for previous line
    SaveData(processed); // Waits for previous line
    
    Console.WriteLine("Done"); // Only executes after everything above
}

Asynchronous Programming:

In asynchronous programming, operations can run concurrently without blocking the thread. The thread is freed to do other work while waiting for I/O operations.

Characteristics:

• Non-blocking execution
• Better resource utilization
• Improved responsiveness
• More complex control flow
• Requires careful exception handling

// Asynchronous example
public async Task ProcessDataAsync()
{
    var data = await FetchDataAsync(); // Thread released during I/O
    var processed = await TransformDataAsync(data); // Non-blocking
    await SaveDataAsync(processed); // Non-blocking
    
    Console.WriteLine("Done");
}

Key differences:

When to use each:

Use Synchronous when:

• CPU-bound operations (calculations)
• Simple console applications
• Operations complete quickly
• Code simplicity is paramount

Use Asynchronous when:

• I/O operations (database, file, network)
• Web applications (ASP.NET Core)
• UI applications (WPF, WinForms)
• Need to handle many concurrent operations
• Scalability is important

// CPU-bound: Synchronous is fine
public int CalculatePrimes(int max)
{
    int count = 0;
    for (int i = 2; i < max; i++)
    {
        if (IsPrime(i)) count++;
    }
    return count;
}

// I/O-bound: Asynchronous is better
public async Task GetWebPageAsync(string url)
{
    using var client = new HttpClient();
    return await client.GetStringAsync(url);
}

SynchronizationContext is an abstraction that represents a scheduling context where code can be executed. It determines which thread executes continuation code after an await.

Purpose:

• Marshals callbacks to the appropriate thread
• Ensures UI updates happen on the UI thread
• Maintains thread affinity for frameworks that require it

How it works:

When you await an async operation:

1. The SynchronizationContext is captured before the await
2. When the operation completes, the continuation is posted back to that context
3. The continuation runs on the correct thread

Different SynchronizationContext types:

1. UI Context (WPF, WinForms):

// In a WPF application
private async void Button_Click(object sender, RoutedEventArgs e)
{
    // Running on UI thread - SynchronizationContext captured
    var data = await FetchDataAsync();
    
    // Automatically back on UI thread - can update UI safely
    TextBlock.Text = data; // Safe - on UI thread
}

2. ASP.NET Context (ASP.NET Framework, not Core):

// In ASP.NET Framework
public async Task Index()
{
    // HttpContext available
    var userId = HttpContext.User.Identity.Name;
    
    var data = await GetDataAsync();
    
    // Still in same request context
    return View(data);
}

3. No Context (Console apps, ASP.NET Core):

// Console application or ASP.NET Core
public async Task ProcessAsync()
{
    // No specific context
    var data = await FetchDataAsync();
    
    // May continue on any thread pool thread
    Console.WriteLine(data);
}

ConfigureAwait and SynchronizationContext:

ConfigureAwait(false) tells the runtime NOT to capture and restore the SynchronizationContext:

// Library code - don't need to return to original context
public async Task GetDataAsync()
{
    // Don't capture context - better performance
    var response = await _httpClient.GetAsync(url).ConfigureAwait(false);
    var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
    
    return ParseData(content); // May run on any thread
}

// UI code - need to return to UI thread
private async void Button_Click(object sender, EventArgs e)
{
    var data = await GetDataAsync(); // Uses ConfigureAwait(false) internally
    
    // This continuation DOES capture context
    // Back on UI thread to update UI
    label.Text = data.ToString();
}

Best practices:

1. Use ConfigureAwait(false) in library code:

// Library method
public async Task CalculateAsync()
{
    await Task.Delay(100).ConfigureAwait(false);
    return 42;
}

1. Don't use ConfigureAwait(false) in UI code:

// UI code
private async void LoadData()
{
    var data = await FetchDataAsync(); // Keep default behavior
    textBox.Text = data; // Must be on UI thread
}

1. ASP.NET Core has no SynchronizationContext:

// ASP.NET Core - ConfigureAwait has no effect
public async Task Index()
{
    // No context to capture
    var data = await GetDataAsync();
    return View(data);
}

Key points:

• SynchronizationContext ensures continuations run on the correct thread
• UI applications have a SynchronizationContext (UI thread)
• ASP.NET Core and console apps typically don't
• Use ConfigureAwait(false) to avoid capturing context when not needed
• Improves performance by avoiding unnecessary thread switches

CancellationToken provides a cooperative cancellation mechanism for async operations. Here are the best practices:

1. Always accept CancellationToken parameters:

// Good: Accepts cancellation token
public async Task FetchDataAsync(CancellationToken cancellationToken = default)
{
    return await _httpClient.GetFromJsonAsync(url, cancellationToken);
}

// Bad: No way to cancel
public async Task FetchDataAsync()
{
    return await _httpClient.GetFromJsonAsync(url);
}

2. Pass tokens through the call chain:

public async Task ProcessOrderAsync(Order order, CancellationToken cancellationToken)
{
    // Pass token to all async calls
    await ValidateOrderAsync(order, cancellationToken);
    await SaveOrderAsync(order, cancellationToken);
    await SendConfirmationAsync(order, cancellationToken);
}

private async Task ValidateOrderAsync(Order order, CancellationToken cancellationToken)
{
    await _validator.ValidateAsync(order, cancellationToken);
}

3. Check for cancellation in long-running operations:

public async Task ProcessItemsAsync(List items, CancellationToken cancellationToken)
{
    foreach (var item in items)
    {
        // Check before each iteration
        cancellationToken.ThrowIfCancellationRequested();
        
        await ProcessItemAsync(item, cancellationToken);
    }
}

4. Use timeout with CancellationTokenSource:

public async Task FetchWithTimeoutAsync()
{
    using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));
    
    try
    {
        return await FetchDataAsync(cts.Token);
    }
    catch (OperationCanceledException)
    {
        throw new TimeoutException("Operation timed out after 30 seconds");
    }
}

5. Link multiple cancellation tokens:

public async Task ProcessAsync(CancellationToken userToken)
{
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromMinutes(5));
    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
        userToken, 
        timeoutCts.Token
    );
    
    // Cancelled if either user cancels OR timeout occurs
    await LongRunningOperationAsync(linkedCts.Token);
}

6. Handle OperationCanceledException appropriately:

public async Task TryProcessAsync(CancellationToken cancellationToken)
{
    try
    {
        var data = await FetchDataAsync(cancellationToken);
        return Result.Success(data);
    }
    catch (OperationCanceledException)
    {
        // Expected when cancelled - don't log as error
        _logger.LogInformation("Operation was cancelled");
        return Result.Cancelled();
    }
    catch (Exception ex)
    {
        // Unexpected exception - log as error
        _logger.LogError(ex, "Operation failed");
        return Result.Failed(ex.Message);
    }
}

7. Register cleanup actions:

public async Task ProcessWithCleanupAsync(CancellationToken cancellationToken)
{
    var resource = await AcquireResourceAsync();
    
    // Register cleanup when cancelled
    using var registration = cancellationToken.Register(() =>
    {
        _logger.LogInformation("Cancellation requested - cleaning up");
        resource.Dispose();
    });
    
    try
    {
        await ProcessResourceAsync(resource, cancellationToken);
    }
    finally
    {
        resource.Dispose();
    }
}

8. Use CancellationToken in ASP.NET Core:

[HttpGet]
public async Task GetData(CancellationToken cancellationToken)
{
    // Automatically cancelled if client disconnects
    var data = await _service.FetchDataAsync(cancellationToken);
    return Ok(data);
}

9. Provide meaningful default values:

// Use default parameter for optional cancellation
public async Task LoadDataAsync(CancellationToken cancellationToken = default)
{
    // Works with or without cancellation token
    await Task.Delay(1000, cancellationToken);
    return new Data();
}

10. Don't swallow OperationCanceledException unnecessarily:

// Bad: Hides cancellation
public async Task ProcessAsync(CancellationToken cancellationToken)
{
    try
    {
        await DoWorkAsync(cancellationToken);
    }
    catch (Exception ex) // Catches OperationCanceledException too
    {
        _logger.LogError(ex, "Error");
        // Cancellation is hidden
    }
}

// Good: Let OperationCanceledException propagate
public async Task ProcessAsync(CancellationToken cancellationToken)
{
    try
    {
        await DoWorkAsync(cancellationToken);
    }
    catch (OperationCanceledException)
    {
        // Let it propagate or handle specifically
        throw;
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Error");
        throw;
    }
}

Complete example:

public class DataService
{
    private readonly HttpClient _httpClient;
    private readonly ILogger _logger;
    
    public async Task ProcessDataAsync(
        string url, 
        CancellationToken cancellationToken = default)
    {
        // Add timeout protection
        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
        cts.CancelAfter(TimeSpan.FromMinutes(5));
        
        try
        {
            // Pass token through call chain
            var data = await FetchDataAsync(url, cts.Token);
            var processed = await TransformDataAsync(data, cts.Token);
            await SaveDataAsync(processed, cts.Token);
            
            return ProcessingResult.Success();
        }
        catch (OperationCanceledException)
        {
            _logger.LogInformation("Processing cancelled");
            return ProcessingResult.Cancelled();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Processing failed");
            return ProcessingResult.Failed(ex.Message);
        }
    }
    
    private async Task FetchDataAsync(string url, CancellationToken cancellationToken)
    {
        return await _httpClient.GetFromJsonAsync(url, cancellationToken);
    }
}

.NET provides several approaches for parallel processing depending on your scenario:

1. Parallel.ForEach (CPU-bound operations):

Best for CPU-intensive operations on collections:

public void ProcessLargeDataset(List items)
{
    Parallel.ForEach(items, new ParallelOptions
    {
        MaxDegreeOfParallelism = Environment.ProcessorCount
    },
    item =>
    {
        // CPU-intensive work
        var result = PerformComplexCalculation(item);
        SaveResult(result);
    });
}

2. Parallel.For (indexed iterations):

public void ProcessArray(int[] numbers)
{
    Parallel.For(0, numbers.Length, i =>
    {
        // Process each element
        numbers[i] = ComplexCalculation(numbers[i]);
    });
}

3. PLINQ (Parallel LINQ):

For declarative parallel queries:

public List ProcessWithPLINQ(List items)
{
    var results = items
        .AsParallel()
        .WithDegreeOfParallelism(8)
        .Where(item => item.IsValid)
        .Select(item => ProcessItem(item))
        .ToList();
    
    return results;
}

// With ordering preserved
public List ProcessOrdered(List items)
{
    var results = items
        .AsParallel()
        .AsOrdered() // Maintain original order
        .Select(item => ProcessItem(item))
        .ToList();
    
    return results;
}

4. Task.WhenAll (I/O-bound operations):

Best for concurrent I/O operations:

public async Task<List> ProcessConcurrentlyAsync(List urls)
{
    // Create all tasks
    var tasks = urls.Select(url => FetchDataAsync(url)).ToList();
    
    // Wait for all to complete
    var results = await Task.WhenAll(tasks);
    
    return results.ToList();
}

5. Parallel processing with cancellation:

public void ProcessWithCancellation(
    List items, 
    CancellationToken cancellationToken)
{
    var options = new ParallelOptions
    {
        CancellationToken = cancellationToken,
        MaxDegreeOfParallelism = Environment.ProcessorCount
    };
    
    try
    {
        Parallel.ForEach(items, options, item =>
        {
            cancellationToken.ThrowIfCancellationRequested();
            ProcessItem(item);
        });
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine("Processing cancelled");
    }
}

6. Partitioning for better load balancing:

public void ProcessWithPartitioning(List items)
{
    var partitioner = Partitioner.Create(items, loadBalance: true);
    
    Parallel.ForEach(partitioner, item =>
    {
        ProcessItem(item);
    });
}

7. Thread-safe result collection:

public List ProcessAndCollectResults(List items)
{
    var results = new ConcurrentBag();
    
    Parallel.ForEach(items, item =>
    {
        var result = ProcessItem(item);
        results.Add(result); // Thread-safe
    });
    
    return results.ToList();
}

8. Async parallel processing with throttling:

public async Task<List> ProcessWithThrottlingAsync(
    List urls, 
    int maxConcurrency)
{
    var semaphore = new SemaphoreSlim(maxConcurrency);
    var tasks = new List<Task>();
    
    foreach (var url in urls)
    {
        await semaphore.WaitAsync();
        
        var task = Task.Run(async () =>
        {
            try
            {
                return await FetchDataAsync(url);
            }
            finally
            {
                semaphore.Release();
            }
        });
        
        tasks.Add(task);
    }
    
    var results = await Task.WhenAll(tasks);
    return results.ToList();
}

9. Producer-Consumer pattern with BlockingCollection:

public void ProcessWithProducerConsumer(IEnumerable items)
{
    var queue = new BlockingCollection(boundedCapacity: 100);
    
    // Producer task
    var producer = Task.Run(() =>
    {
        foreach (var item in items)
        {
            queue.Add(item);
        }
        queue.CompleteAdding();
    });
    
    // Consumer tasks
    var consumers = Enumerable.Range(0, Environment.ProcessorCount)
        .Select(_ => Task.Run(() =>
        {
            foreach (var item in queue.GetConsumingEnumerable())
            {
                ProcessItem(item);
            }
        }))
        .ToArray();
    
    Task.WaitAll(consumers);
}

10. Dataflow (TPL Dataflow) for complex pipelines:

using System.Threading.Tasks.Dataflow;

public async Task ProcessPipelineAsync(List items)
{
    var downloadBlock = new TransformBlock(
        async item => await DownloadAsync(item),
        new ExecutionDataflowBlockOptions 
        { 
            MaxDegreeOfParallelism = 10 
        });
    
    var processBlock = new TransformBlock(
        data => ProcessData(data),
        new ExecutionDataflowBlockOptions 
        { 
            MaxDegreeOfParallelism = Environment.ProcessorCount 
        });
    
    var saveBlock = new ActionBlock(
        async data => await SaveAsync(data),
        new ExecutionDataflowBlockOptions 
        { 
            MaxDegreeOfParallelism = 5 
        });
    
    // Link the pipeline
    downloadBlock.LinkTo(processBlock, new DataflowLinkOptions { PropagateCompletion = true });
    processBlock.LinkTo(saveBlock, new DataflowLinkOptions { PropagateCompletion = true });
    
    // Post items
    foreach (var item in items)
    {
        await downloadBlock.SendAsync(item);
    }
    
    downloadBlock.Complete();
    await saveBlock.Completion;
}

Best practices:

1. Choose the right approach:

   • CPU-bound: Parallel.ForEach, PLINQ
   • I/O-bound: Task.WhenAll, async/await
   • Complex pipelines: TPL Dataflow

2. Control degree of parallelism:

   var options = new ParallelOptions 
   { 
       MaxDegreeOfParallelism = Environment.ProcessorCount 
   };
   

3. Handle exceptions properly:

   try
   {
       Parallel.ForEach(items, item => ProcessItem(item));
   }
   catch (AggregateException ae)
   {
       foreach (var ex in ae.InnerExceptions)
       {
           _logger.LogError(ex, "Processing failed");
       }
   }
   

4. Use thread-safe collections:

   • ConcurrentBag, ConcurrentQueue, ConcurrentDictionary

5. Avoid over-parallelization:

   • Too many threads can degrade performance
   • Measure and optimize based on actual workload

Task.FromResult() creates a completed task with a result value, while Task.Run() queues work to run on the ThreadPool. The key difference is that Task.FromResult() is synchronous and immediate, while Task.Run() is asynchronous and offloads work to a background thread.

Key Differences:

Example:

public class TaskCreationComparison
{
    // Task.FromResult() - for already computed values
    public async Task<string> GetCachedDataAsync(string key)
    {
        // Simulate cache lookup (synchronous operation)
        string cachedValue = GetFromCache(key);
        
        if (cachedValue != null)
        {
            // Already have the value - use Task.FromResult()
            return await Task.FromResult(cachedValue);
        }
        
        // Need to fetch from database (async operation)
        return await FetchFromDatabaseAsync(key);
    }
    
    // Task.Run() - for CPU-bound work
    public async Task<int> CalculatePrimeCountAsync(int maxNumber)
    {
        // CPU-intensive work - offload to ThreadPool
        return await Task.Run(() =>
        {
            int count = 0;
            for (int i = 2; i <= maxNumber; i++)
            {
                if (IsPrime(i))
                    count++;
            }
            return count;
        });
    }
    
    // WRONG: Using Task.Run() for already computed values
    public async Task<string> GetCachedDataWrongAsync(string key)
    {
        string cachedValue = GetFromCache(key);
        
        if (cachedValue != null)
        {
            // BAD: Unnecessary thread switching overhead
            return await Task.Run(() => cachedValue);
        }
        
        return await FetchFromDatabaseAsync(key);
    }
    
    // WRONG: Using Task.FromResult() for CPU-bound work
    public async Task<int> CalculatePrimeCountWrongAsync(int maxNumber)
    {
        // BAD: Blocks the current thread
        int count = 0;
        for (int i = 2; i <= maxNumber; i++)
        {
            if (IsPrime(i))
                count++;
        }
        
        return await Task.FromResult(count);
    }
    
    private string GetFromCache(string key)
    {
        // Simulate cache lookup
        return key == "cached" ? "cached_value" : null;
    }
    
    private async Task<string> FetchFromDatabaseAsync(string key)
    {
        await Task.Delay(1000); // Simulate database call
        return $"database_value_for_{key}";
    }
    
    private bool IsPrime(int number)
    {
        if (number < 2) return false;
        for (int i = 2; i * i <= number; i++)
        {
            if (number % i == 0) return false;
        }
        return true;
    }
}

Advanced Examples:

public class AdvancedTaskCreation
{
    // Task.FromResult() for configuration values
    public async Task<AppSettings> GetAppSettingsAsync()
    {
        // Configuration is already loaded - no need for async
        var settings = LoadConfiguration();
        return await Task.FromResult(settings);
    }
    
    // Task.FromResult() for constants
    public async Task<string> GetApiVersionAsync()
    {
        return await Task.FromResult("v1.0");
    }
    
    // Task.FromResult() for simple calculations
    public async Task<decimal> CalculateTaxAsync(decimal amount, decimal rate)
    {
        decimal tax = amount * rate;
        return await Task.FromResult(tax);
    }
    
    // Task.Run() for file processing
    public async Task<string> ProcessLargeFileAsync(string filePath)
    {
        return await Task.Run(() =>
        {
            // CPU-intensive file processing
            var lines = File.ReadAllLines(filePath);
            var processedLines = lines
                .Where(line => !string.IsNullOrWhiteSpace(line))
                .Select(line => line.ToUpper())
                .OrderBy(line => line)
                .ToArray();
            
            return string.Join("\n", processedLines);
        });
    }
    
    // Task.Run() for image processing
    public async Task<byte[]> ResizeImageAsync(byte[] imageData, int width, int height)
    {
        return await Task.Run(() =>
        {
            // CPU-intensive image processing
            using (var originalImage = Image.FromStream(new MemoryStream(imageData)))
            using (var resizedImage = new Bitmap(originalImage, width, height))
            using (var stream = new MemoryStream())
            {
                resizedImage.Save(stream, ImageFormat.Jpeg);
                return stream.ToArray();
            }
        });
    }
    
    private AppSettings LoadConfiguration()
    {
        // Simulate configuration loading
        return new AppSettings { DatabaseConnection = "Server=localhost", ApiKey = "secret" };
    }
}

public class AppSettings
{
    public string DatabaseConnection { get; set; }
    public string ApiKey { get; set; }
}

Performance Comparison:

public class PerformanceComparison
{
    public async Task ComparePerformance()
    {
        const int iterations = 10000;
        
        // Task.FromResult() - very fast
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            await Task.FromResult(i);
        }
        stopwatch.Stop();
        Console.WriteLine($"Task.FromResult(): {stopwatch.ElapsedMilliseconds}ms");
        
        // Task.Run() - slower due to thread switching
        stopwatch.Restart();
        for (int i = 0; i < iterations; i++)
        {
            await Task.Run(() => i);
        }
        stopwatch.Stop();
        Console.WriteLine($"Task.Run(): {stopwatch.ElapsedMilliseconds}ms");
    }
}

Best Practices:

Use Task.FromResult() when:

• You already have the computed value
• Converting synchronous APIs to async
• Returning constants or configuration values
• Simple calculations that don't block

Use Task.Run() when:

• Performing CPU-intensive work
• Processing large files or data
• Image/video processing
• Mathematical calculations
• Any work that could block the UI thread

Avoid Task.Run() when:

• You already have the result
• The work is already asynchronous
• You're just wrapping synchronous I/O operations
• The operation is very fast

Common Anti-patterns:

// BAD: Unnecessary Task.Run()
public async Task<string> GetUserNameAsync(int userId)
{
    var user = await GetUserFromDatabaseAsync(userId);
    return await Task.Run(() => user.Name); // Unnecessary!
}

// GOOD: Use Task.FromResult() or just return directly
public async Task<string> GetUserNameAsync(int userId)
{
    var user = await GetUserFromDatabaseAsync(userId);
    return user.Name; // Simple return
}

// BAD: Blocking with Task.FromResult()
public async Task<string> ProcessDataAsync(string data)
{
    var result = ExpensiveProcessing(data); // Blocks current thread
    return await Task.FromResult(result);
}

// GOOD: Use Task.Run() for CPU work
public async Task<string> ProcessDataAsync(string data)
{
    return await Task.Run(() => ExpensiveProcessing(data));
}

Summary:

• Task.FromResult(): For already computed values, no thread switching
• Task.Run(): For CPU-bound work that needs to run on background thread
• Choose based on whether you need to offload work or just return a value
• Performance matters: avoid unnecessary thread switching

Implementing async/await in custom classes requires following specific patterns to ensure proper async behavior, exception handling, and resource management. The key is to implement the async pattern correctly and provide both sync and async versions when appropriate.

Basic Async Implementation:

public class DataService
{
    private readonly HttpClient httpClient;
    
    public DataService(HttpClient httpClient)
    {
        this.httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
    }
    
    // Async method with proper naming convention
    public async Task<string> GetDataAsync(string url, CancellationToken cancellationToken = default)
    {
        try
        {
            // Use ConfigureAwait(false) in library code
            var response = await httpClient.GetAsync(url, cancellationToken).ConfigureAwait(false);
            response.EnsureSuccessStatusCode();
            
            var content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            return content;
        }
        catch (HttpRequestException ex)
        {
            // Wrap in more specific exception
            throw new DataServiceException($"Failed to retrieve data from {url}", ex);
        }
    }
    
    // Async method with return value
    public async Task<T> GetDataAsync<T>(string url, CancellationToken cancellationToken = default)
    {
        var json = await GetDataAsync(url, cancellationToken).ConfigureAwait(false);
        return JsonSerializer.Deserialize<T>(json);
    }
    
    // Async method with multiple operations
    public async Task<ProcessedData> ProcessDataAsync(string input, CancellationToken cancellationToken = default)
    {
        // Validate input
        if (string.IsNullOrEmpty(input))
            throw new ArgumentException("Input cannot be null or empty", nameof(input));
        
        // Step 1: Fetch data
        var rawData = await GetDataAsync("https://api.example.com/data", cancellationToken).ConfigureAwait(false);
        
        // Step 2: Process data (CPU-bound work)
        var processedData = await Task.Run(() => ProcessRawData(rawData), cancellationToken).ConfigureAwait(false);
        
        // Step 3: Save result
        await SaveDataAsync(processedData, cancellationToken).ConfigureAwait(false);
        
        return processedData;
    }
    
    private ProcessedData ProcessRawData(string rawData)
    {
        // CPU-intensive processing
        Thread.Sleep(1000); // Simulate processing
        return new ProcessedData { Content = rawData.ToUpper(), ProcessedAt = DateTime.UtcNow };
    }
    
    private async Task SaveDataAsync(ProcessedData data, CancellationToken cancellationToken)
    {
        // Simulate saving to database
        await Task.Delay(100, cancellationToken).ConfigureAwait(false);
    }
}

public class ProcessedData
{
    public string Content { get; set; }
    public DateTime ProcessedAt { get; set; }
}

public class DataServiceException : Exception
{
    public DataServiceException(string message) : base(message) { }
    public DataServiceException(string message, Exception innerException) : base(message, innerException) { }
}

Advanced Async Patterns:

public class FileProcessor
{
    private readonly SemaphoreSlim semaphore;
    private readonly ILogger logger;
    
    public FileProcessor(int maxConcurrency = 4, ILogger logger = null)
    {
        this.semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
        this.logger = logger;
    }
    
    // Async method with concurrency control
    public async Task<ProcessingResult> ProcessFileAsync(string filePath, CancellationToken cancellationToken = default)
    {
        await semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
        
        try
        {
            logger?.LogInformation($"Starting to process file: {filePath}");
            
            // Validate file exists
            if (!File.Exists(filePath))
                throw new FileNotFoundException($"File not found: {filePath}");
            
            // Read file asynchronously
            var content = await File.ReadAllTextAsync(filePath, cancellationToken).ConfigureAwait(false);
            
            // Process content (CPU-bound)
            var processedContent = await Task.Run(() => ProcessContent(content), cancellationToken).ConfigureAwait(false);
            
            // Write result asynchronously
            var outputPath = GetOutputPath(filePath);
            await File.WriteAllTextAsync(outputPath, processedContent, cancellationToken).ConfigureAwait(false);
            
            logger?.LogInformation($"Successfully processed file: {filePath}");
            
            return new ProcessingResult
            {
                InputPath = filePath,
                OutputPath = outputPath,
                ProcessedAt = DateTime.UtcNow,
                Success = true
            };
        }
        catch (OperationCanceledException)
        {
            logger?.LogWarning($"Processing cancelled for file: {filePath}");
            throw;
        }
        catch (Exception ex)
        {
            logger?.LogError(ex, $"Error processing file: {filePath}");
            return new ProcessingResult
            {
                InputPath = filePath,
                ProcessedAt = DateTime.UtcNow,
                Success = false,
                Error = ex.Message
            };
        }
        finally
        {
            semaphore.Release();
        }
    }
    
    // Batch processing with progress reporting
    public async Task<BatchProcessingResult> ProcessFilesAsync(
        IEnumerable<string> filePaths, 
        IProgress<ProcessingProgress> progress = null,
        CancellationToken cancellationToken = default)
    {
        var tasks = filePaths.Select(async filePath =>
        {
            var result = await ProcessFileAsync(filePath, cancellationToken).ConfigureAwait(false);
            progress?.Report(new ProcessingProgress { FilePath = filePath, Completed = true });
            return result;
        });
        
        var results = await Task.WhenAll(tasks).ConfigureAwait(false);
        
        return new BatchProcessingResult
        {
            TotalFiles = results.Length,
            SuccessfulFiles = results.Count(r => r.Success),
            FailedFiles = results.Count(r => !r.Success),
            Results = results
        };
    }
    
    private string ProcessContent(string content)
    {
        // Simulate CPU-intensive processing
        Thread.Sleep(500);
        return content.ToUpper();
    }
    
    private string GetOutputPath(string inputPath)
    {
        return Path.ChangeExtension(inputPath, ".processed");
    }
    
    public void Dispose()
    {
        semaphore?.Dispose();
    }
}

public class ProcessingResult
{
    public string InputPath { get; set; }
    public string OutputPath { get; set; }
    public DateTime ProcessedAt { get; set; }
    public bool Success { get; set; }
    public string Error { get; set; }
}

public class BatchProcessingResult
{
    public int TotalFiles { get; set; }
    public int SuccessfulFiles { get; set; }
    public int FailedFiles { get; set; }
    public ProcessingResult[] Results { get; set; }
}

public class ProcessingProgress
{
    public string FilePath { get; set; }
    public bool Completed { get; set; }
}

Async Stream Implementation:

public class DataStreamer
{
    private readonly HttpClient httpClient;
    
    public DataStreamer(HttpClient httpClient)
    {
        this.httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient));
    }
    
    // Async enumerable for streaming data
    public async IAsyncEnumerable<DataItem> StreamDataAsync(
        string endpoint,
        [EnumeratorCancellation] CancellationToken cancellationToken = default)
    {
        var response = await httpClient.GetAsync(endpoint, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
            .ConfigureAwait(false);
        
        response.EnsureSuccessStatusCode();
        
        using var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
        using var reader = new StreamReader(stream);
        
        string line;
        while ((line = await reader.ReadLineAsync().ConfigureAwait(false)) != null)
        {
            cancellationToken.ThrowIfCancellationRequested();
            
            if (!string.IsNullOrWhiteSpace(line))
            {
                var item = ParseDataItem(line);
                yield return item;
            }
        }
    }
    
    // Async method with timeout
    public async Task<string> GetDataWithTimeoutAsync(string url, TimeSpan timeout)
    {
        using var cts = new CancellationTokenSource(timeout);
        
        try
        {
            var response = await httpClient.GetAsync(url, cts.Token).ConfigureAwait(false);
            return await response.Content.ReadAsStringAsync().ConfigureAwait(false);
        }
        catch (OperationCanceledException) when (cts.Token.IsCancellationRequested)
        {
            throw new TimeoutException($"Request timed out after {timeout.TotalSeconds} seconds");
        }
    }
    
    private DataItem ParseDataItem(string line)
    {
        // Simple parsing logic
        var parts = line.Split(',');
        return new DataItem
        {
            Id = parts[0],
            Value = parts[1],
            Timestamp = DateTime.Parse(parts[2])
        };
    }
}

public class DataItem
{
    public string Id { get; set; }
    public string Value { get; set; }
    public DateTime Timestamp { get; set; }
}

Async Factory Pattern:

public class DatabaseConnection
{
    private readonly string connectionString;
    
    private DatabaseConnection(string connectionString)
    {
        this.connectionString = connectionString;
    }
    
    // Async factory method
    public static async Task<DatabaseConnection> CreateAsync(string connectionString)
    {
        if (string.IsNullOrEmpty(connectionString))
            throw new ArgumentException("Connection string cannot be null or empty", nameof(connectionString));
        
        var connection = new DatabaseConnection(connectionString);
        
        // Test the connection asynchronously
        await connection.TestConnectionAsync().ConfigureAwait(false);
        
        return connection;
    }
    
    private async Task TestConnectionAsync()
    {
        // Simulate connection test
        await Task.Delay(100).ConfigureAwait(false);
        
        // In real implementation, you would test the actual database connection
        if (connectionString.Contains("invalid"))
            throw new InvalidOperationException("Invalid connection string");
    }
    
    public async Task<T> QueryAsync<T>(string sql, CancellationToken cancellationToken = default)
    {
        // Simulate database query
        await Task.Delay(50, cancellationToken).ConfigureAwait(false);
        
        // Return mock data
        return default(T);
    }
}

Best Practices for Async Implementation:

1. Naming Convention:

   • Always suffix async methods with Async
   • Use descriptive names that indicate the operation

2. Return Types:

   • Use Task for void operations
   • Use Task<T> for operations that return values
   • Use IAsyncEnumerable<T> for streaming data

3. Cancellation Support:

   • Always accept CancellationToken parameters
   • Pass cancellation tokens to all async operations
   • Check cancellationToken.IsCancellationRequested in loops

4. Exception Handling:

   • Let exceptions bubble up naturally
   • Wrap low-level exceptions in domain-specific exceptions
   • Use ConfigureAwait(false) in library code

5. Resource Management:

   • Use using statements for disposable resources
   • Implement IAsyncDisposable when needed
   • Clean up resources in finally blocks

6. Performance:

   • Use ConfigureAwait(false) in library code
   • Avoid blocking async methods with .Result or .Wait()
   • Use Task.Run() only for CPU-bound work

Async/await has both benefits and performance costs. Understanding these implications is crucial for making informed decisions about when to use async programming and how to optimize it.

Performance Benefits:

1. Better Resource Utilization
2. Improved Scalability
3. Non-blocking I/O Operations
4. Better User Experience

Performance Costs:

1. Memory Allocation Overhead
2. State Machine Generation
3. Context Switching
4. Exception Handling Overhead

Example:

public class PerformanceAnalysis
{
    private readonly HttpClient httpClient = new HttpClient();
    
    // Synchronous version - blocks thread
    public string GetDataSync(string url)
    {
        var response = httpClient.GetStringAsync(url).Result; // BAD: Blocking
        return response;
    }
    
    // Asynchronous version - better resource utilization
    public async Task<string> GetDataAsync(string url)
    {
        var response = await httpClient.GetStringAsync(url).ConfigureAwait(false);
        return response;
    }
    
    // Performance comparison
    public async Task ComparePerformance()
    {
        const int iterations = 1000;
        var urls = Enumerable.Range(1, iterations)
            .Select(i => $"https://api.example.com/data/{i}")
            .ToArray();
        
        // Synchronous approach - sequential, blocking
        var stopwatch = Stopwatch.StartNew();
        var syncResults = new List<string>();
        
        foreach (var url in urls.Take(10)) // Limit to 10 for demo
        {
            syncResults.Add(GetDataSync(url));
        }
        
        stopwatch.Stop();
        Console.WriteLine($"Synchronous: {stopwatch.ElapsedMilliseconds}ms for 10 requests");
        
        // Asynchronous approach - concurrent, non-blocking
        stopwatch.Restart();
        var asyncTasks = urls.Take(10).Select(GetDataAsync);
        var asyncResults = await Task.WhenAll(asyncTasks);
        
        stopwatch.Stop();
        Console.WriteLine($"Asynchronous: {stopwatch.ElapsedMilliseconds}ms for 10 requests");
    }
}

Memory Allocation Analysis:

public class MemoryAllocationAnalysis
{
    // High allocation - creates new Task for each operation
    public async Task<string> HighAllocationAsync(string input)
    {
        // Each await creates a state machine
        var step1 = await ProcessStep1Async(input).ConfigureAwait(false);
        var step2 = await ProcessStep2Async(step1).ConfigureAwait(false);
        var step3 = await ProcessStep3Async(step2).ConfigureAwait(false);
        
        return step3;
    }
    
    // Lower allocation - fewer await points
    public async Task<string> LowerAllocationAsync(string input)
    {
        // Batch operations to reduce state machine overhead
        var (step1, step2, step3) = await ProcessAllStepsAsync(input).ConfigureAwait(false);
        
        return step3;
    }
    
    // Optimized - minimal allocation
    public Task<string> OptimizedAsync(string input)
    {
        // For simple operations, consider if async is needed
        if (IsCached(input))
        {
            return Task.FromResult(GetCachedValue(input));
        }
        
        return ProcessAsync(input);
    }
    
    private async Task<string> ProcessStep1Async(string input)
    {
        await Task.Delay(10).ConfigureAwait(false);
        return input.ToUpper();
    }
    
    private async Task<string> ProcessStep2Async(string input)
    {
        await Task.Delay(10).ConfigureAwait(false);
        return input + "_processed";
    }
    
    private async Task<string> ProcessStep3Async(string input)
    {
        await Task.Delay(10).ConfigureAwait(false);
        return input + "_final";
    }
    
    private async Task<(string, string, string)> ProcessAllStepsAsync(string input)
    {
        await Task.Delay(30).ConfigureAwait(false); // Simulate all work
        return (input.ToUpper(), input.ToUpper() + "_processed", input.ToUpper() + "_processed_final");
    }
    
    private bool IsCached(string input) => input.Length < 5;
    private string GetCachedValue(string input) => input.ToUpper();
    private async Task<string> ProcessAsync(string input)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return input.ToUpper();
    }
}

When Async Hurts Performance:

public class AsyncPerformancePitfalls
{
    // BAD: Unnecessary async for simple operations
    public async Task<int> BadAsync(int a, int b)
    {
        // This creates unnecessary overhead
        return await Task.FromResult(a + b).ConfigureAwait(false);
    }
    
    // GOOD: Simple synchronous operation
    public int GoodSync(int a, int b)
    {
        return a + b;
    }
    
    // BAD: Using Task.Run() for I/O operations
    public async Task<string> BadTaskRunAsync(string url)
    {
        // Task.Run() is for CPU-bound work, not I/O
        return await Task.Run(async () =>
        {
            var client = new HttpClient();
            return await client.GetStringAsync(url);
        }).ConfigureAwait(false);
    }
    
    // GOOD: Direct async I/O
    public async Task<string> GoodAsync(string url)
    {
        var client = new HttpClient();
        return await client.GetStringAsync(url).ConfigureAwait(false);
    }
    
    // BAD: Blocking async methods
    public string BadBlockingAsync(string url)
    {
        // This defeats the purpose of async
        return GetDataAsync(url).Result; // Can cause deadlocks
    }
    
    // BAD: Fire-and-forget without proper error handling
    public void BadFireAndForget(string url)
    {
        // Exceptions will be lost
        _ = GetDataAsync(url);
    }
    
    // GOOD: Proper fire-and-forget with error handling
    public void GoodFireAndForget(string url)
    {
        _ = GetDataAsync(url).ContinueWith(task =>
        {
            if (task.IsFaulted)
            {
                // Log the exception
                Console.WriteLine($"Error: {task.Exception?.GetBaseException().Message}");
            }
        }, TaskContinuationOptions.OnlyOnFaulted);
    }
    
    private async Task<string> GetDataAsync(string url)
    {
        var client = new HttpClient();
        return await client.GetStringAsync(url).ConfigureAwait(false);
    }
}

Performance Optimization Techniques:

public class AsyncOptimization
{
    private readonly HttpClient httpClient = new HttpClient();
    private readonly SemaphoreSlim semaphore = new SemaphoreSlim(10, 10); // Limit concurrency
    
    // Optimized: Limit concurrent operations
    public async Task<string[]> GetDataWithConcurrencyLimitAsync(string[] urls)
    {
        var tasks = urls.Select(async url =>
        {
            await semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                return await httpClient.GetStringAsync(url).ConfigureAwait(false);
            }
            finally
            {
                semaphore.Release();
            }
        });
        
        return await Task.WhenAll(tasks).ConfigureAwait(false);
    }
    
    // Optimized: Use ValueTask for hot paths
    public async ValueTask<string> GetCachedDataAsync(string key)
    {
        if (TryGetFromCache(key, out string cachedValue))
        {
            return cachedValue; // No allocation
        }
        
        var value = await FetchFromDatabaseAsync(key).ConfigureAwait(false);
        CacheValue(key, value);
        return value;
    }
    
    // Optimized: Batch operations
    public async Task<Dictionary<string, string>> GetMultipleDataAsync(string[] keys)
    {
        // Single database call instead of multiple
        return await FetchMultipleFromDatabaseAsync(keys).ConfigureAwait(false);
    }
    
    // Optimized: Use ConfigureAwait(false) in library code
    public async Task<string> LibraryMethodAsync(string input)
    {
        var result = await ProcessInputAsync(input).ConfigureAwait(false);
        return await TransformResultAsync(result).ConfigureAwait(false);
    }
    
    private bool TryGetFromCache(string key, out string value)
    {
        // Simulate cache lookup
        value = key == "cached" ? "cached_value" : null;
        return value != null;
    }
    
    private void CacheValue(string key, string value)
    {
        // Simulate caching
    }
    
    private async Task<string> FetchFromDatabaseAsync(string key)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return $"database_value_for_{key}";
    }
    
    private async Task<Dictionary<string, string>> FetchMultipleFromDatabaseAsync(string[] keys)
    {
        await Task.Delay(100).ConfigureAwait(false);
        return keys.ToDictionary(k => k, k => $"database_value_for_{k}");
    }
    
    private async Task<string> ProcessInputAsync(string input)
    {
        await Task.Delay(50).ConfigureAwait(false);
        return input.ToUpper();
    }
    
    private async Task<string> TransformResultAsync(string input)
    {
        await Task.Delay(50).ConfigureAwait(false);
        return input + "_transformed";
    }
}

Performance Measurement:

public class AsyncPerformanceMeasurement
{
    public async Task MeasureAsyncPerformance()
    {
        const int iterations = 10000;
        
        // Measure memory allocation
        var initialMemory = GC.GetTotalMemory(true);
        
        // Test 1: Simple async method
        var stopwatch = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            await SimpleAsyncMethod().ConfigureAwait(false);
        }
        stopwatch.Stop();
        
        var finalMemory = GC.GetTotalMemory(false);
        var allocatedMemory = finalMemory - initialMemory;
        
        Console.WriteLine($"Simple async method:");
        Console.WriteLine($"  Time: {stopwatch.ElapsedMilliseconds}ms");
        Console.WriteLine($"  Memory allocated: {allocatedMemory / 1024.0:F2} KB");
        Console.WriteLine($"  Memory per call: {allocatedMemory / (double)iterations:F2} bytes");
        
        // Test 2: Synchronous equivalent
        initialMemory = GC.GetTotalMemory(true);
        stopwatch.Restart();
        
        for (int i = 0; i < iterations; i++)
        {
            SimpleSyncMethod();
        }
        stopwatch.Stop();
        
        finalMemory = GC.GetTotalMemory(false);
        allocatedMemory = finalMemory - initialMemory;
        
        Console.WriteLine($"\nSynchronous method:");
        Console.WriteLine($"  Time: {stopwatch.ElapsedMilliseconds}ms");
        Console.WriteLine($"  Memory allocated: {allocatedMemory / 1024.0:F2} KB");
        Console.WriteLine($"  Memory per call: {allocatedMemory / (double)iterations:F2} bytes");
    }
    
    private async Task<int> SimpleAsyncMethod()
    {
        await Task.Delay(1).ConfigureAwait(false);
        return 42;
    }
    
    private int SimpleSyncMethod()
    {
        Thread.Sleep(1);
        return 42;
    }
}

Best Practices for Performance:

1. Use async only when beneficial:

   • I/O operations (network, file, database)
   • Operations that can benefit from concurrency
   • Operations that might block the UI thread

2. Avoid async for:

   • Simple calculations
   • Already computed values
   • CPU-bound work (use Task.Run() instead)

3. Optimize hot paths:

   • Use ValueTask for frequently called methods
   • Cache results when possible
   • Batch operations when feasible

4. Monitor performance:

   • Profile memory allocation
   • Measure execution time
   • Use performance counters

5. Use proper patterns:

   • ConfigureAwait(false) in library code
   • Limit concurrency with SemaphoreSlim
   • Handle exceptions properly

Summary:

• Async/await has overhead but provides scalability benefits
• Use async for I/O operations, not CPU-bound work
• Monitor memory allocation and execution time
• Optimize hot paths with ValueTask and caching
• Use proper async patterns to avoid performance pitfalls

Constructors cannot be async, and static methods have specific considerations for async operations. This limitation requires alternative patterns and approaches to handle asynchronous initialization and operations.

Constructor Limitations and Solutions:

public class DatabaseService
{
    private readonly string connectionString;
    private Task<IDbConnection> connectionTask;
    
    // Constructor cannot be async
    public DatabaseService(string connectionString)
    {
        this.connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
        
        // Start async initialization but don't await
        this.connectionTask = InitializeConnectionAsync();
    }
    
    // Async initialization method
    private async Task<IDbConnection> InitializeConnectionAsync()
    {
        var connection = new SqlConnection(connectionString);
        await connection.OpenAsync().ConfigureAwait(false);
        return connection;
    }
    
    // Public method to get the connection when needed
    public async Task<IDbConnection> GetConnectionAsync()
    {
        return await connectionTask.ConfigureAwait(false);
    }
    
    // Example usage
    public async Task<User> GetUserAsync(int userId)
    {
        var connection = await GetConnectionAsync().ConfigureAwait(false);
        // Use connection for database operations
        return new User { Id = userId, Name = "John Doe" };
    }
}

public interface IDbConnection
{
    Task OpenAsync();
    void Close();
}

public class SqlConnection : IDbConnection
{
    private readonly string connectionString;
    
    public SqlConnection(string connectionString)
    {
        this.connectionString = connectionString;
    }
    
    public async Task OpenAsync()
    {
        await Task.Delay(100).ConfigureAwait(false); // Simulate connection
    }
    
    public void Close()
    {
        // Close connection
    }
}

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

Factory Pattern for Async Initialization:

public class FileProcessor
{
    private readonly string filePath;
    private readonly Stream fileStream;
    
    // Private constructor
    private FileProcessor(string filePath, Stream fileStream)
    {
        this.filePath = filePath;
        this.fileStream = fileStream;
    }
    
    // Async factory method
    public static async Task<FileProcessor> CreateAsync(string filePath)
    {
        if (string.IsNullOrEmpty(filePath))
            throw new ArgumentException("File path cannot be null or empty", nameof(filePath));
        
        if (!File.Exists(filePath))
            throw new FileNotFoundException($"File not found: {filePath}");
        
        // Perform async initialization
        var fileStream = await OpenFileAsync(filePath).ConfigureAwait(false);
        
        return new FileProcessor(filePath, fileStream);
    }
    
    private static async Task<Stream> OpenFileAsync(string filePath)
    {
        // Simulate async file opening
        await Task.Delay(100).ConfigureAwait(false);
        return File.OpenRead(filePath);
    }
    
    public async Task<string> ReadContentAsync()
    {
        using var reader = new StreamReader(fileStream);
        return await reader.ReadToEndAsync().ConfigureAwait(false);
    }
    
    public void Dispose()
    {
        fileStream?.Dispose();
    }
}

// Usage
public class FileProcessorExample
{
    public static async Task ProcessFileExample()
    {
        // Use factory method for async initialization
        using var processor = await FileProcessor.CreateAsync("data.txt");
        var content = await processor.ReadContentAsync();
        Console.WriteLine(content);
    }
}

Static Async Methods:

public static class UtilityService
{
    // Static async methods are allowed
    public static async Task<string> GetConfigurationAsync(string key)
    {
        // Simulate async configuration loading
        await Task.Delay(100).ConfigureAwait(false);
        return $"config_value_for_{key}";
    }
    
    public static async Task<T> DeserializeJsonAsync<T>(string json)
    {
        await Task.Delay(50).ConfigureAwait(false); // Simulate processing
        return JsonSerializer.Deserialize<T>(json);
    }
    
    // Static async method with caching
    private static readonly ConcurrentDictionary<string, Task<string>> cache = new();
    
    public static async Task<string> GetCachedDataAsync(string key)
    {
        return await cache.GetOrAdd(key, async k =>
        {
            await Task.Delay(200).ConfigureAwait(false); // Simulate expensive operation
            return $"expensive_data_for_{k}";
        }).ConfigureAwait(false);
    }
    
    // Static async method with error handling
    public static async Task<bool> TryGetDataAsync(string url, out string data)
    {
        data = null;
        
        try
        {
            using var client = new HttpClient();
            data = await client.GetStringAsync(url).ConfigureAwait(false);
            return true;
        }
        catch (Exception)
        {
            return false;
        }
    }
}

// Usage of static async methods
public class StaticAsyncExample
{
    public static async Task UseStaticAsyncMethods()
    {
        // Direct usage
        var config = await UtilityService.GetConfigurationAsync("database");
        Console.WriteLine(config);
        
        // With caching
        var data1 = await UtilityService.GetCachedDataAsync("key1");
        var data2 = await UtilityService.GetCachedDataAsync("key1"); // Uses cache
        
        // With error handling
        if (await UtilityService.TryGetDataAsync("https://api.example.com/data", out string result))
        {
            Console.WriteLine(result);
        }
        else
        {
            Console.WriteLine("Failed to get data");
        }
    }
}

Lazy Initialization Pattern:

public class LazyAsyncService
{
    private readonly Lazy<Task<ExpensiveResource>> lazyResource;
    
    public LazyAsyncService()
    {
        // Lazy initialization of async resource
        lazyResource = new Lazy<Task<ExpensiveResource>>(async () =>
        {
            await Task.Delay(1000).ConfigureAwait(false); // Simulate expensive initialization
            return new ExpensiveResource();
        });
    }
    
    public async Task<string> DoWorkAsync()
    {
        // Resource is initialized only when first accessed
        var resource = await lazyResource.Value.ConfigureAwait(false);
        return await resource.ProcessAsync().ConfigureAwait(false);
    }
}

public class ExpensiveResource
{
    public async Task<string> ProcessAsync()
    {
        await Task.Delay(100).ConfigureAwait(false);
        return "Processed by expensive resource";
    }
}

Async Initialization with IAsyncDisposable:

public class AsyncInitializedService : IAsyncDisposable
{
    private readonly string connectionString;
    private IDbConnection connection;
    private bool isInitialized = false;
    
    public AsyncInitializedService(string connectionString)
    {
        this.connectionString = connectionString;
    }
    
    // Async initialization method
    public async Task InitializeAsync()
    {
        if (isInitialized)
            return;
        
        connection = new SqlConnection(connectionString);
        await connection.OpenAsync().ConfigureAwait(false);
        isInitialized = true;
    }
    
    // Ensure initialization before use
    private async Task EnsureInitializedAsync()
    {
        if (!isInitialized)
        {
            await InitializeAsync().ConfigureAwait(false);
        }
    }
    
    public async Task<User> GetUserAsync(int userId)
    {
        await EnsureInitializedAsync().ConfigureAwait(false);
        
        // Use the initialized connection
        return new User { Id = userId, Name = "John Doe" };
    }
    
    public async ValueTask DisposeAsync()
    {
        if (connection != null)
        {
            connection.Close();
            connection = null;
        }
        isInitialized = false;
        await Task.CompletedTask.ConfigureAwait(false);
    }
}

// Usage with using statement
public class AsyncDisposableExample
{
    public static async Task UseAsyncDisposable()
    {
        await using var service = new AsyncInitializedService("connection_string");
        await service.InitializeAsync();
        
        var user = await service.GetUserAsync(1);
        Console.WriteLine(user.Name);
    } // DisposeAsync is called automatically
}

Static Constructor with Async Initialization:

public static class StaticAsyncInitializer
{
    private static readonly Task initializationTask;
    private static bool isInitialized = false;
    
    // Static constructor - cannot be async
    static StaticAsyncInitializer()
    {
        initializationTask = InitializeAsync();
    }
    
    private static async Task InitializeAsync()
    {
        // Perform async initialization
        await Task.Delay(1000).ConfigureAwait(false);
        isInitialized = true;
    }
    
    // Public method to ensure initialization
    public static async Task EnsureInitializedAsync()
    {
        await initializationTask.ConfigureAwait(false);
    }
    
    public static async Task<string> GetDataAsync()
    {
        await EnsureInitializedAsync().ConfigureAwait(false);
        return "Data from initialized service";
    }
}

Best Practices:

1. For Constructors:

   • Use factory methods for async initialization
   • Start async operations but don't await them
   • Provide methods to access async results
   • Use lazy initialization when appropriate

2. For Static Methods:

   • Static async methods are perfectly fine
   • Use caching for expensive operations
   • Handle errors appropriately
   • Consider thread safety

3. Alternative Patterns:

   • Factory pattern for async object creation
   • Lazy initialization for expensive resources
   • IAsyncDisposable for async cleanup
   • Static async methods for utility functions

4. Common Pitfalls to Avoid:

   • Don't use .Result or .Wait() in constructors
   • Don't make constructors async (it's not allowed)
   • Don't forget to handle exceptions in async initialization
   • Don't block on async operations in constructors

Summary:

• Constructors cannot be async - use factory methods or lazy initialization
• Static async methods are allowed and useful for utility functions
• Use proper patterns like factory methods, lazy initialization, and IAsyncDisposable
• Always handle exceptions and ensure proper resource cleanup