In today’s article, we will discuss HttpClient C# Guidelines and Best Practices that developers can follow for developing HTTP-based APIs or microservices.

We will go through various aspects of how to use/create/instantiate HttpClient C# instances in the .NET /.NET Core ecosystem.

I did touch upon this topic in my last article on the Using HTTPClientFactory in ASP.NET Core Application already, however, today’s article is more on the guidelines and best practices while using HTTPClient instances to access resources over the network.

Developers may easily use HTTPClient to handle HTTP headers and status codes, download/upload files, use web services, and consume APIs.

HttpClient is designed as a shared instance that is also thread-safe if used properly.

The HttpClient class is designed as a broker that clients can use to access the resource over the network.

In the host-based application under heavy load communication, there could be multiple instances of HTTPClient getting created.

Over the years it has experienced a few common issues like resource exhaustion caused by multiple invocations of the HTTP request object and then recently discovered issues with .NET Core like Stale DNS, etc.

Let’s see, how HttpClient is currently being used in applications and issues related to that with some real-life examples.

HTTPClient AntiPattern 1 – use of new HttpClient()

You instantiate the HttpClient object using a new operator for every request.

Example:

HttpClient httpClient = new HttpClient();

OR

Using Handler

       
            var httpClientHandler = new HttpClientHandler()
            {
                Credentials = new NetworkCredential(config.User, config.Pwd),
            };

            HttpClient httpClient = new HttpClient(httpClientHandler);

            HttpResponseMessage response = await httpClient.GetAsync(config.Url).Result;
..
..

In the above example, the HttpClient object is created for each request using a new operator.

Here in the above example, the developer’s intention looks to be creating a long-lived instance that will be disposed of/garbage collected depending on the implementation.

Note– If the instances are injected through IOC container pipelines then only it will be disposed of by the framework as default behavior or else it becomes the creator’s responsibility to manage the objects’ lifetime.

HttpClient AntiPattern 2 – use of Using statement

In this anti-pattern example, the developer instantiates the HttpClient object using block,

Other examples without using any handler,

Example: With C# HttpClientHandler

          var httpClientHandler = new HttpClientHandler()
            {
               Credentials = new NetworkCredential(config.User, config.Pwd),
            };

            HttpResponseMessage response;
            using (HttpClient httpClient = new HttpClient(httpClientHandler))
            {
                response = await httpClient.GetAsync(config.Url);
            }

  
        

Similar to above example 1, In the above example, the HttpClient object is being created for each request.

Here in the above example, the developer is aware that the HttpClient object is an unmanaged resource and implements IDisposable.

Here instance gets created and called within the ‘using‘ block assuming this will be disposed of/garbage collected immediately but in reality, there is no guarantee that such resources will get disposed of at a given time.

Why Anti-pattern?

Using HTTPClient in the above-mentioned manner is considered to be an anti-pattern due to common problems like Resource Exhaustion and Stale DNS Problems as discussed below,

HttpClient – Resource Exhaustion and Stale DNS Problem

In both, of the above Example1 and Example2 below are the consideration and issues associated.

• Each new HTTPClient object creates a new socket instance.

• Instantiating HTTPClient objects for each request might exhaust the number of sockets available under heavy loads.

• HTTPClient object doesn’t release the sockets immediately even if it is called using the “using” (IDisposable) block.

• This may lead to SocketExceptions.

• Singleton or Static HTTPClient objects as specified above should help to resolve most issues.

• In .NET Core, it was found that Singleton or Static HTTPClient object doesn’t respect the DNS update or change in the .NET core resulting in a Stale DNS problem

Resolutions for HttpClient AntiPatterns

As per Microsoft guidelines,

HttpClient is intended to be instantiated once and re-used throughout the request flow of an application.

Especially in server applications, creating a new HttpClient instance for every request will exhaust the number of sockets available under heavy loads.

This will result in SocketException errors.

Resolution 1 – Use HttpClientFactory

Let’s create a HttpClient instance using HttpClientFactory.(Available only in .NET Core 2.1 and above)

Using HTTPClientFactory resolves the Resource exhaustion problems by pooling HTTPMessageHandler.

It also solves Stale DNS problems by cycling HTTPMessageHandler instances at regular intervals.

Each instance of HttpClient object created from IHttpClientFactory, uses an HttpMessageHandler that’s pooled and reused to reduce resource consumption.

This also depends upon HttpMessageHandler objects lifetime which has a lifetime of two minutes typically by default.

Basic or Named HttpClient object

For more details see here: Named HTTP Client using HTTPClientFactory

Typed HttpClient objects

For more details see here: Typed HTTP Client using HTTPClientFactory

Resolution 2 – Use Static Instance of HttpClient

It’s recommended to create a single static HttpClient instance and use the same shared instance for all requests.

This approach is more useful and convenient in case you have a no-host application like a batch process or console application.

Also, for applications where dependency injection is a bit difficult to manage, this approach is a possible option.

HttpClient is designed to be thread-safe and intended to be shared.

If you have a console or form application where you need to perform repetitive HTTP connection, this approach is preferable.

The below example shows a static instance created in the controller but the same if you have layered architecture, same can be used in the controller/API or business or data access layer as needed.

    [Route("api/[controller]")]
    [ApiController]
    public class PaymentController : ControllerBase
    {

        static readonly HttpClient client = new HttpClient();
        
        [HttpGet]
        public  async Task<IActionResult> Get()
        {
            HttpClientHandler httpClientHandler = new HttpClientHandler()
            {
                Credentials = new NetworkCredential("username", "****"),
            };

            var response = await client.GetAsync("https://www.thecodebuzz.com/api/");
            return Ok(response.Content.ReadAsStringAsync().Result);
        }

Additionally, you can use Constructor to initialize the HttpClient Instance.

Below is just an example to demonstrate the use. However please use layered architecture and inject services per need.

public class PaymentController : ControllerBase
    {
        private static  HttpClient _client;
        public PaymentController() => _client = new HttpClient();
..
}

Use PooledConnectionLifetime – DNS update scenarios,

Additionally, it’s recommended to use the PooledConnectionLifetime settings if DNS entries change regularly,

public class PaymentController : ControllerBase
{
    private static readonly HttpClient httpClient;

    static PaymentController ()
    {
        var socketsHandler = new SocketsHttpHandler
        {
            PooledConnectionLifetime = TimeSpan.FromMinutes(2)
        };

        httpClient = new HttpClient(socketsHandler);
    }
}

The above use of PooledConnectionLifetime limits the lifetime of the connection by setting the SocketsHttpHandler.PooledConnectionLifetime property.

In case the DNS is replaced, the connection will perform the DNS lookup and restore the connection.

Other Resolution and Best Practices

Set Timeout on HttpClient Instance

Specify a timeout value to prevent requests from hanging indefinitely.

This helps in handling scenarios where the remote server is unresponsive or experiencing delays.

Example

httpClientInstance.Timeout = TimeSpan.FromSeconds(10);

Use await with async Methods

When making asynchronous HTTP requests using HttpClient, utilize the async/await pattern to ensure responsiveness and avoid blocking the calling thread.

Configuring HTTPClient correctly

Configure the HttpClient instance with appropriate timeouts, default headers, certificates, authentication, and other settings like HttpContext based on your application’s requirements.

Use try-catch blocks or async/await error handling patterns when making requests with HttpClient.

Using HttpClientHandler for customizing behavior

Consider using the HttpClientHandler class to customize the underlying HTTP behavior, such as handling certificates or enabling compression.

Handling exceptions and errors

Handle exceptions such as HttpRequestException and TaskCanceledException to gracefully handle network issues, timeouts, or other errors.

Properly logging or handling exceptions ensures the robustness and reliability of your application.

Implementing Resiliency – Retries and exponential backoff

When dealing with transient errors like network connectivity issues or temporary server failures, consider implementing Httpclient Resiliency retry mechanisms with exponential backoff.

This allows your application to automatically retry failed requests, increasing the chances of successful execution.

HttpClient Security considerations

When making requests to secure endpoints, ensure that you properly handle and validate SSL/TLS certificates.

Follow secure coding practices and validate and sanitize user inputs to prevent security vulnerabilities like injection attacks.

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

In this article, we learned about HttpClient instancing usage’s best practices and guidelines. We understood that by following best practices, we can avoid common problems of Resource exhaustion, stale DNS, Memory leaks, or network connectivity issues while using HttpClient objects.

Using HttpClientfactory or A static shared instance is the recommended way to use the HTTPClient object in the application.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post How to use HttpClient C#- Guidelines and Best Practices first appeared on TheCodeBuzz.

In today’s post, we will see how to use HttpClientFactory in ASP.NET Core with examples in ASP.NET Core and invoke HTTP Services in .NET Core or ASP.NET Core.

It’s a best practice to use the HTTPClientFactory object to create an HTTPClient object as it addresses known issues related to HTTPClient usage in the traditional way in .NET Core.

Today in this article, we will cover below aspects,

We shall also understand a few approaches to create HTTPClient requests using the below techniques,

• Basic HTTPClient

• Named HTTPClient

• Typed HTTPClient

All the above techniques leverage the IHTTPClientFactory interface to DI (Dependency Injection) required client object.

DI with middleware framework lets the API pipeline control the lifetime management of HTTPClient request objects instead of doing it manually.

Over the years it has been observed a few common issues like resource exhaustion caused by multiple invocations of the HTTP request object.

This was also followed by the realization that one should create Static or Singleton HTTP Client instances but which again ultimately found to be an issue in the recent .NET Core framework in the form of Stale DNS problems.

HTTPClient in .NET Core – Common Issues

Let’s discuss a few issues associated with using HttpClient in the old way.

Resource Exhaustion Problem

This was a commonly known issue while using the HTTPClient objects.

Please note that the HTTPClient implements IDisposable.

So basic understanding is to use ‘using(..)’ blocks to dispose of the objects but using blocks doesn’t release the socket immediately when heavy load operations are performed. Let’s not forget that socket objects are unmanaged resources.

Characteristics and Limitations:

• Each new HTTPClient object creates a new socket instance.

• Instantiating HTTPClient objects for each request might exhaust the number of sockets available. Example – Async operation with heavy loads.

• HTTPClient object doesn’t release the sockets immediately even if it is called using the “using” (IDisposable) block.

• This may lead to Socket exceptions.

HTTPClient creating using ‘new’ and ‘using’ blocks,

As per Microsoft guidelines,

HttpClient is intended to be instantiated once and re-used throughout the life of an application. Especially in server applications, creating a new HttpClient instance for every request will exhaust the number of sockets available under heavy loads. This will result in SocketException errors.

See here for more details.

Stale DNS (Domain Name System) problems

As discussed above a Singleton or Static HTTPClient object as specified above should help to resolve the most issues.

But in .NET Core, it was found that Singleton or Static HTTPClient object doesn’t respect the DNS update or change in the .NET core.

This is an additional problem that was found in the .NET Core framework. I am not sure if this issue exists in the regular .NET framework

The above common problems can be easily resolved by using HTTPClientfactory introduced recently in .NET Core ( 2.1 and above).

Top 10 benefits pf HttpClientFactory

Create an HTTP request using HTTPClientFactory – Guidelines

Create an ASP.NET Core Project

Let’s look at the basic HttpClient approach where we shall be creating plain HTTPClient using HTTPClientFactory.

Basic HTTPClient Request

You create an HTTPClient object using HTTPClientFactory.

HTTPClientFactory lets you DI inject the HTTPClient objects using an explicit dependency principle. Required instances can be enabled and disabled as required from the API pipeline as middleware.

Update ConfigureServices method

  public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            services.AddHttpClient();
        }

Once injected HTTpClientFactory from the Your data Service Constructor, the instance can be used for creating the HTTPClient object as shown below,

The below example shows HttpClientFactory injected through Controller but ideally you can inject it in your DataService model wherever appropriate.

HttpClientFactory -Named HTTPClient usage with examples

I have discussed this technique in detail in the below post,

• Named HTTPClient using IHttpClientFactory in ASP.NET Core – Part2

This technique has an advantage you can configure multiple HTTP clients with custom configuration as required like using policy, network credentials, specific headers, or security tokens as needed.

HttpClientFactory -Typed HTTPClient usage with examples

This is also one of the most preferred and easy techniques to create type HTTP Client objects.

• Typed HTTPClient using HttpClientFactory in ASP.NET Core -Part 3

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

In this article, we looked at how to use HTTPClientFactory for creating HTTPClient request objects to invoke HTTP Services in .NET Core or ASP.NET Core. We saw three basic approaches to creating HTTPClient using HTTPClientFactorylike Basic HTTPClient, Named HTTPClient, and Typed HTTPClient request.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post HttpClientFactory in ASP.NET Core with examples first appeared on TheCodeBuzz.

Today in this article, we will see how to use Configure HttpClientfactory using Autofac DI Container in ASP.NET Core.

As we know .NET Core framework has leveraged the Explicit Dependency Injection (DI) principle very well and almost every functionality/service used in the application can be injected through DI.

Here Developers have a choice to use the default DI container framework provided by the application or use a custom DI solution like Autofac etc.

Today in this article, we will cover below aspects,

Container controls the lifetime of services used and the consumer need not have to worry about disposing of them once after every use.

There are a lot of benefits of the DI approach like,

• Separation of concern
• Independently deployable unit
• Easily Testable units
• High performance
• Easy maintenance

Getting Started

1. Open Visual Studio
2. Let’s create an ASP.NET core API application.

Create ASP.NET Core API

Please choose any ASP.NET Core API project template. Filters are supported in most ASP.NET Core project templates,

PM> Install-Package Autofac.Extensions.DependencyInjection -Version <version>

OR

Use Nuget manager,

Step 1 – Register HostBuilder to use Autofac Factory

Register the Generic Host Builder to use Autofac Factory.

In your Program.cs in the main method please add the UseServiceProviderFactory extension and use the AutofacServiceProviderFactory.

  public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseServiceProviderFactory(new AutofacServiceProviderFactory())
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup<Startup>();
                });

Step 2 – Define Autofac DI Container with HttpClientfactory

Define Autofac DI Container with services as below in Startup.cs

  
public void ConfigureContainer(ContainerBuilder builder)
        {
            //Register your services
            builder.RegisterType<BusinessLayer>().As<IBusinessLayer>();
            builder.Register(c => c.Resolve<IHttpClientFactory>().CreateClient())
            .As<HttpClient>();


        }

The above code registers the IHttpClientFactory within the Autofac DI container instead of the built-in DI container.

Step 3 – Use HttpClientfactory using Dependency Injection

Please perform dependency Injection (DI) of HttpClientfactory and other required Services using Constructor Injection as shown below,

    [ApiController]
    [Route("[controller]")]
    public class WeatherForecastController : ControllerBase
    {
        private readonly IBusinessLayer _businessLayer;

        private readonly ILogger<WeatherForecastController> _logger;

        private readonly IHttpClientFactory _clientFactory;

        public WeatherForecastController(ILogger<WeatherForecastController> logger, 
                                        IBusinessLayer businessLayer, 
                                        IHttpClientFactory clientFactory)
        {
            _logger = logger;
            _businessLayer = businessLayer;
            _clientFactory = clientFactory;
        }

        [HttpGet]
        public async Task<IActionResult> GetAsync()
        {

            var client = _clientFactory.CreateClient("TheCodeBuzz");

          ...
          ...
         }

With the above configuration, you should be all set to use HttpClientfactory using Autofac DI.

References :

• Create Named HTTPClient using IHttpClientFactory in ASP.NET Core
• Typed HTTPClient using HttpClientFactory in ASP.NET Core -Part2

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Configure HttpClientfactory using Autofac DI first appeared on TheCodeBuzz.

In today’s post, we will see the HttpClientFactory HTTP GET POST examples. We shall create a basic or named HttpClient instance.

In this instance, we shall use HTTP GET, POST PUT, or DELETE methods.

Today in this article, we will cover below aspects,

In our previous article, we already also looked at approaches to create HTTPClient requests in ASP.NET Core API.

• Basic HTTPClient
• Named HTTPClient
• Typed HTTPClient

Let’s look at a few examples to invoke HTTP GET and POST methods using HttpClientfactory.

As discussed in the previous article I have already setup the named HttpClientclientFactory to create the required HttpClient instance as below,

Calling the GET method using HttpClientFactory

Below is a sample GET method that shows creating a named instance of HttpClient using HttpClientFactory and invoking the GET method asynchronously.

        //GET:  api/Accounts/PersonalAccounts/1234
        [HttpGet]
        [Route("PersonalAccounts")]
        public async Task<IActionResult> GetAccountDetails(int employeeId)
        {
            var client = _clientFactory.CreateClient("AccountClient");

            var response = await client.GetAsync($"api/accounts/PersonalAccounts/{employeeId}");

            if (response.IsSuccessStatusCode)
            {
                return Ok(response.Content.ReadAsStreamAsync().Result);
            }
            else
            {
                return StatusCode(500, "Something Went Wrong! Error Occured");
            }
        }

In the above example, we are using the IHttpClientFactory instance to create a client. Using generated client we invoke the GET call for the given Uri and return the result.

Calling the POST method using HttpClientFactory

Below is a sample POST method example. Here I am creating a named instance of HttpClient using HttpClientFactory and invoking the POST method asynchronously.

Note: Below samples are shown using direct usage of post-call in Controller. Ideally please structure your code considering the separation of code.

Ideally, the POST method should also return the location of newly created resources as per REST guidelines.

Calling the PUT method using HttpClientFactory

Below is a sample PUT method using HttpClientFactory and invoking the Put method asynchronously.

        //PUT:  api/Accounts/1234
        [HttpPut]
        public async Task<IActionResult> Put(int employeeId, Customer customer)
        {
            CusotmerDetails employeeDetails = null;

            var client = _clientFactory.CreateClient("AccountClient");

            HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(customer)
                , Encoding.UTF8, "application/json");

            HttpResponseMessage response = await client.PutAsync($"api/accounts/{employeeId}", httpContent);

            if (!response.IsSuccessStatusCode)
            {
                return StatusCode(500, "Something Went Wrong! Error Occured");
            }

            employeeDetails = JsonConvert.DeserializeObject<CusotmerDetails>(response.Content.ReadAsStringAsync().Result);

            return Ok(employeeDetails);
        }

Calling the DELETE method using HttpClientFactory

Below is a sample example for DELETE using HttpClientFactory. Below we are using HttpClientFactory and invoking the method asynchronously.

        //DELETE:  api/Accounts/1234
        [HttpDelete]
        public async Task<IActionResult> Delete(int employeeId)
        {
            CusotmerDetails employeeDetails = null;

            var client = _clientFactory.CreateClient("AccountClient");

            HttpResponseMessage response = await client.DeleteAsync($"api/accounts/{employeeId}");

            if (!response.IsSuccessStatusCode)
            {
                return StatusCode(500, "Something Went Wrong! Error Occured");
            }

            employeeDetails = JsonConvert.DeserializeObject<CusotmerDetails>(response.Content.ReadAsStringAsync().Result);

            return Ok(employeeDetails);
        }

References:

• Using HTTPClient Best Practices and Anti-Patterns

That’s all! Happy Coding!

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post HttpClientFactory HTTP GET POST examples first appeared on TheCodeBuzz.

In today’s post, we will see how to create typed HTTPClient requests using HTTPClientFactory in .NET Core or ASP.NET Core.

In our last article, we understood the Differences between HTTPClient and HTTPClientFactory and also learned the Best practices for using HTTPClientFactory to create an HTTPClient object addressing the known issues of HTTPClient usage in the traditional way in ASP.NET Core.

Today in this article, we will cover below aspects,

In our previous article, we already also looked at Basic HTTPClient and Named HTTPClient approaches to create HTTPClient requests using a similar concept.

Create Typed HTTPClient

Let’s look at the step by step to understand and create a Typed HTTPClient approach where we shall be creating typed HTTPClient using the IHTTPClientFactory interface.

Create an ASP.NET Core Project

Add using namespace ‘System.Net.Http’ in the code to access HTTPClient and IHTTPClientFactory

Please update the ConfigureServices method in Startup.cs as below,

public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllers();
            
            //Create Typed client
            services.AddHttpClient<AccountClient>();
         }

Below is our typed HTTPClient i.e AccountClient implementation

AccountClient class here not just addressing basic class responsibility. It is mainly addressing HttpClient creation through DI. This class will make sure you get the best available HttpClient object from the pool and address your calls.

Defining AccountClient using services.AddHttpClient will let you attach any specific requirements like a custom header certificate or compression logic easily.

public class AccountClient
    {
        private readonly HttpClient _client;
        private readonly IConfiguration _configuration;
        public AccountClient(HttpClient client, IConfiguration configuration)
        {
            _client = client;
            _configuration = configuration;
        }
        public async Task<string>GetAccount()
        {
            var uri = new Uri(_configuration.GetValue<string>("AccountURL"));
            var response = await _client.GetAsync(uri);
            if (response.IsSuccessStatusCode)
            {
                return response.Content.ReadAsStringAsync().Result;
            }
            else
            {
                return null;
            }
           
        }
    }

Typed HTTPClient via Controller DI

Once defined the typed HTTPClient AccountClient can be injected from the Constructor in any other module or class where we need to call HTTP services.

This instance can be used for invoking the required operations as shown below,

Below is an example using Controller but ideally your actual implementation, you might call it in Service layer or Data access layer,or Infra layer.

AccountClient will be available to use in every class/module in a project as required. Lifetime management of injected HTTPClient instances will be done through the API pipeline itself.

Additionally, this technique lets you control and configure HTTPClient’s request with custom configuration of Policy, Security, or delegates as required.

References:

• Using HTTPClient Best Practices and Anti-Patterns
• Create Named HTTPClient using IHttpClientFactory in ASP.NET Core

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

In this article, we looked at how to use HTTPClientFactory to create a Typed HTTPClient request object to invoke HTTP services in ASP.NET Core. This technique also lets you control lifetime and configure HTTPClient’s request with custom Policy, Security, or delegates as required.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Typed HTTPClient using HttpClientFactory in ASP.NET Core – Part2 first appeared on TheCodeBuzz.