C# Async/Await Tips and Best Practices

A collection of tips and best practices for using async and await in C#. It also highlights common pitfalls and explains why certain practices should be avoided.

---

1. Do Not Decorate a Constructor with async

Why?

Constructors in C# cannot be marked as async. This is because constructors are meant to initialize an object synchronously. If you need to perform asynchronous operations during object initialization, consider using a factory method or an InitializeAsync method.

Incorrect Usage:

public class MyClass
{
    public MyClass()
    {
        await InitializeAsync(); // Compilation error: await cannot be used in a constructor.
    }

    private async Task InitializeAsync()
    {
        // Async initialization logic
    }
}

Correct Approach:

public class MyClass
{
    private MyClass() { }

    public static async Task<MyClass> CreateAsync()
    {
        var instance = new MyClass();
        await instance.InitializeAsync();
        return instance;
    }

    private async Task InitializeAsync()
    {
        // Async initialization logic
    }
}

---

2. Avoid async void Methods

Why?

async void methods are dangerous because:

• They cannot be awaited, making it difficult to handle exceptions or determine when the method has completed.
• Unhandled exceptions in async void methods can crash the application by propagating to the synchronization context (e.g., in UI applications).

Incorrect Usage:

public async void DoSomethingAsync()
{
    await Task.Delay(1000);
    throw new Exception("This will crash the app!");
}

Correct Approach:

Use async Task instead of async void to ensure proper exception handling and awaitability.

public async Task DoSomethingAsync()
{
    await Task.Delay(1000);
    throw new Exception("This can be caught by the caller.");
}

---

3. Always Await Tasks

Why?

If you don't await a Task, the code will continue executing without waiting for the task to complete. This can lead to unexpected behavior, especially if the task throws an exception or if the result is needed later.

Incorrect Usage:

public void DoWork()
{
    Task.Run(() => LongRunningOperation()); // Not awaited
}

private async Task LongRunningOperation()
{
    await Task.Delay(1000);
}

Correct Approach:

Always await asynchronous tasks to ensure proper execution flow and exception handling.

public async Task DoWorkAsync()
{
    await Task.Run(() => LongRunningOperation());
}

private async Task LongRunningOperation()
{
    await Task.Delay(1000);
}

---

4. Use ConfigureAwait(false) in Library Code

Why?

In library code, using ConfigureAwait(false) prevents deadlocks by not capturing the synchronization context. This is especially important in non-UI applications or libraries that may be used in different environments.

Example:

public async Task<string> GetDataAsync()
{
    var data = await SomeAsyncOperation().ConfigureAwait(false);
    return data;
}

When Not to Use

In UI applications, avoid ConfigureAwait(false) when you need to return to the UI thread after the async operation.

---

5. Never Use .Wait() or .Result

Why?

Blocking on asynchronous code (e.g., using .Result or .Wait()) can lead to deadlocks, especially in applications with a synchronization context (e.g., UI or ASP.NET).

Incorrect Usage:

public string GetData()
{
    return SomeAsyncOperation().Result; // Potential deadlock
}

Correct Approach:

Use await to asynchronously wait for the result.

public async Task<string> GetDataAsync()
{
    return await SomeAsyncOperation();
}

---

6. Handle Exceptions in Async Methods

Why?

Unhandled exceptions in async methods can crash your application. Always use try-catch blocks to handle exceptions in async code.

Example:

public async Task DoWorkAsync()
{
    try
    {
        await SomeAsyncOperation();
    }
    catch (Exception ex)
    {
        // Handle the exception
        Console.WriteLine($"Error: {ex.Message}");
    }
}

---

7. Use IAsyncEnumerable<T> for Asynchronous Streaming

Why?

IAsyncEnumerable<T> allows asynchronous iteration over data streams, preventing unnecessary memory consumption and improving performance.

Example:

public async IAsyncEnumerable<int> GetNumbersAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(100);
        yield return i;
    }
}

---

8. Implement IAsyncDisposable for Resource Cleanup

Why?

When dealing with asynchronous resources (e.g., database connections, file streams), implement IAsyncDisposable to ensure proper cleanup.

Example:

public class MyResource : IAsyncDisposable
{
    public async ValueTask DisposeAsync()
    {
        await CleanupAsync();
    }

    private async Task CleanupAsync()
    {
        await Task.Delay(100); // Simulating resource cleanup
    }
}

---

9. Use SafeFireAndForget()

Why?

If you need to start a fire-and-forget task, consider using an extension method like SafeFireAndForget() to prevent unobserved exceptions from crashing your application.

Example:

public void DoSomething()
{
    SomeAsyncOperation().SafeFireAndForget();
}

---

10. Use .WaitAsync(CancellationToken)

Why?

When awaiting a task with a timeout or cancellation support, use .WaitAsync(CancellationToken) instead of manually handling timeouts.

Example:

public async Task PerformOperationAsync(CancellationToken cancellationToken)
{
    await SomeAsyncOperation().WaitAsync(cancellationToken);
}

---

Conclusion

Using async and await effectively in C# requires understanding the underlying mechanics and potential pitfalls. By following these tips, you can write more efficient, maintainable, and robust asynchronous code. Always test your async code thoroughly to avoid deadlocks, unhandled exceptions, and other common issues.