Effective Error Handling with HttpClient in C#

Effective Error Handling with HttpClient in C#

When working with HttpClient in .NET Core, handling errors gracefully is crucial for building robust applications. This guide will walk you through common error scenarios, best practices for error handling, and provide practical C# examples using top-level statements introduced in C# 6.0.

Common HttpClient Error Messages

HttpClient is used to send HTTP requests and receive responses. However, errors can occur during this process. Here are some common error messages and what they mean:

"One or more errors occurred": This generic message often indicates that multiple issues happened during the request. It could be a combination of network issues, server problems, or client-side errors.

"The operation has timed out": This error usually occurs when the request takes too long to complete. It might be due to network latency or server overload.

"No connection could be made because the target machine actively refused it": This indicates that the server is not accepting connections, possibly due to being down or misconfigured.

.NET Core HttpClient Error Handling

Handling errors in HttpClient involves checking the response status code and catching exceptions that may arise during the request process. Here’s a step-by-step approach:

Check the Response Status Code

You should always check the status code of the HTTP response to determine if the request was successful. Here’s how you can do it:

using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
var request = new HttpRequestMessage(HttpMethod.Get, "https://api.example.com/data");

try
{
    var response = await client.SendAsync(request);
    
    if (!response.IsSuccessStatusCode)
    {
        Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
    }
    else
    {
        var content = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Response: {content}");
    }
}
catch (HttpRequestException e)
{
    Console.WriteLine($"Request error: {e.Message}");
}
catch (TaskCanceledException e)
{
    Console.WriteLine($"Request timeout: {e.Message}");
}

Handle Specific Exceptions

Handling specific exceptions helps to provide more detailed error information:

try
{
    // Send request and handle response
}
catch (HttpRequestException e)
{
    // Handle network-related errors
    Console.WriteLine($"Request error: {e.Message}");
}
catch (TaskCanceledException e)
{
    // Handle timeout errors
    Console.WriteLine($"Request timeout: {e.Message}");
}

Best Practices for HttpClient Error Handling

Use a Retry Policy

Implementing a retry policy can help handle transient errors. Consider using libraries like Polly for advanced retry strategies.

using Polly;
using System;
using System.Net.Http;
using System.Threading.Tasks;

var client = new HttpClient();
var retryPolicy = Policy.Handle<HttpRequestException>()
                        .WaitAndRetryAsync(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));

try
{
    await retryPolicy.ExecuteAsync(async () =>
    {
        var response = await client.GetAsync("https://api.example.com/data");
        response.EnsureSuccessStatusCode();
        var content = await response.Content.ReadAsStringAsync();
        Console.WriteLine($"Response: {content}");
    });
}
catch (HttpRequestException e)
{
    Console.WriteLine($"Request error: {e.Message}");
}

Log Detailed Error Information

Always log detailed error information for debugging purposes. This includes the exception message, stack trace, and any relevant HTTP response details.

catch (HttpRequestException e)
{
    // Log exception details
    Console.WriteLine($"Request error: {e.Message}");
    // Consider logging additional details such as the stack trace
}

Use Timeouts Wisely

Set appropriate timeouts for your requests to avoid long waits on unresponsive servers:

var client = new HttpClient
{
    Timeout = TimeSpan.FromSeconds(30) // Set a timeout of 30 seconds
};

Implement Circuit Breaker

A circuit breaker pattern can prevent overwhelming a failing service by stopping requests temporarily.

// Implement a circuit breaker using Polly

By following these best practices and understanding common error scenarios, you can handle errors in HttpClient more effectively and build more resilient applications.