Best practices for initializing a HttpClient

Question

This is a made up scenario and I want to find the best way of implementing and learn which are the best practices.

I am writing a service that makes a get request to an api which requires an Authorization header, the problem is that I am initializing a new client for each service, I was thinking if it is the best to have a singleton client and use that anywhere in different services.

Here I have my BlogService, where I initialize the client and then add the Authorization header, username and password will be in configs but this is just an example.

namespace MyDemoProject.Services
{
  public class BlogService : IBlogService
  {
    private readonly HttpClient client;
    private string username = "myUsername";
    private string password = "myPassword";
    private static string url = "https://example.com/api/blogs";

    public BlogService()
    {
      client = new HttpClient();
      string encoded = System.Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));
      client.DefaultRequestHeaders.Add("Authorization", "Basic " + encoded);
    }
    public async Task<string> GetAllBlogs()
    {
      var request = await client.GetAsync(url);
      var data = await request.Content.ReadAsStringAsync();
      return data;
    }
  }
}

And here I have my CommentService, which is very similar, but with a different url. This is a simple example and it could be included in the same BlogService, but suppose that I want to make it granular for maintainability and scalability.

namespace MyDemoProject.Services
{
  public class CommentService : ICommentService
  {
    private readonly HttpClient client;
    private string username = "myUsername";
    private string password = "myPassword";
    private static string url = "https://example.com/api/comments";

    public CommentService()
    {
      client = new HttpClient();
      string encoded = System.Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));
      client.DefaultRequestHeaders.Add("Authorization", "Basic " + encoded);
    }
    public async Task<string> GetAllComments()
    {
      var request = await client.GetAsync(url);
      var data = await request.Content.ReadAsStringAsync();
      return data;
    }
  }
}

Is there any better way of implementing this, and are there any issues with this implementation?

Answer 1

The best practice in .net 6 is to use IHttpClientFactory to avoid the creation of new HttpClient each time you have to use it and to avoid code duplication: https://learn.microsoft.com/en-us/dotnet/architecture/microservices/implement-resilient-applications/use-httpclientfactory-to-implement-resilient-http-requests.

Here a simple example based on your code. You have to register and configure IHttpClientFactory like:

_ = services.AddHttpClient("MyHttpClientKey", (serviceProvider, httpClient) =>
{
   private string username = "myUsername";
   private string password = "myPassword";
   string encoded = System.Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));

   _ = httpClient.BaseAddress = new Uri("https://example.com/api/comments");
   _ = httpClient.Timeout = TimeSpan.FromSeconds(30);
   httpClient.DefaultRequestHeaders.Add("Authorization", "Basic " + encoded);
});

Then you can use HttpClient injecting it in your classes:

public class CommentService : ICommentService
{
    private readonly HttpClient client;

    public CommentService(IHttpClientFactory httpClientFactory)
    {
        httpClient = httpClientFactory.CreateClient("MyHttpClientKey");
    }

    public async Task<string> GetAllComments()
    {
      var request = await client.GetAsync(url);
      var data = await request.Content.ReadAsStringAsync();
      return data;
    }
}

Hope it helps!

Answer 2

You should not try to manually create instance of HttpClient better avoid it as it might cause unwanted issues due to DNS cache and not recycling of TCP connections.

Use HttpClientFactory instead, it will take care of creating and maintaining the HttpClient for you

Add this dependency from nuget Microsoft.Extensions.DependencyInjection

If you are using dependency injection add this code in startup file
In Startup.cs
  public void ConfigureServices(IServiceCollection services)
        {
services.AddScoped<BearerTokenHandler>();
services.AddHttpClient<ICommentService, CommentService >()
 .ConfigureHttpClient(client =>
                {
                    client.BaseAddress = new Uri("https://example.com/api");
                }).AddHttpMessageHandler<BearerTokenHandler>();;
}


 namespace MyDemoProject.Services
{

public class BearerTokenHandler : DelegatingHandler
    {
        private const string BasicAuthenticationScheme = "Basic";
 private string username = "myUsername";
    private string password = "myPassword";
        public BearerTokenHandler()
        {
        }

        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            string encoded = System.Convert.ToBase64String(Encoding.GetEncoding("ISO-8859-1").GetBytes(username + ":" + password));

            request.Headers.Authorization = new AuthenticationHeaderValue(BasicAuthenticationScheme, token);

            return await base.SendAsync(request, cancellationToken);
        }
    }

  public class CommentService : ICommentService
  {
    private readonly HttpClient client;

    public CommentService(HttpClient httpClient)
    {
client = httpclient
      }
    public async Task<string> GetAllComments()
    {
string response = null;
                    using (var request = new HttpRequestMessage( HttpMethod.GET, "comments"))
                    {
                response = await client.SendAsync(request);

          }
      var data = await response.Content.ReadAsStringAsync();
  
      return data;
    }
  }
}