Ten become one.

Benefits:

1. As you can see, the original 10 connections have become one. (please don't mind that the target IP of the two examples is different -- SLB (load balancing) results in Baidu IP)

2. In addition, because of the reuse of HttpClient, each RPC request actually saves the time to create a channel, which is also a significant improvement in performance pressure testing. Once, because of this move, the TPS (system throughput) of the web project was increased from 600 to 2000 + in an instant, and the page request time was reduced from 1-3s to 100-300ms, which even made the test team members worship (including the fine tuning of some business codes, of course) , but after knowing the reason, the project performance improvement brought by a small change... Addictive:)

3. As for how to create a static HttpClient for reuse, you can create a "global" static object directly or through various DI frameworks according to the actual project.

Initial understanding of HttpClientFactory

According to Microsoft source code analysis, HttpClient inherits from HttpMessageInvoker, which is essentially HttpClientHandler.

HttpClient created by HttpClientFactory, that is, HttpClientHandler. However, these httpclients are put into the "pool". The factory will automatically determine whether to create or reuse each time it creates. (default life cycle is 2min)

If you still can't understand it, you can refer to the relationship between Task and Thread. When you met the problem of HttpClient, you always wondered when Microsoft would officially launch an HttpClient Factory. Although it took so many years until. NET CORE 2.1, it was also exciting.

Recommended articles

 public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            //other codes
            
            services.AddHttpClient ("client_ 1 ", config = > / / name = client specified here_ 1. It is convenient for us to take this example later
            {
                config.BaseAddress= new Uri("http://client_1.com");
                config.DefaultRequestHeaders.Add("header_1","header_1");
            });
            services.AddHttpClient("client_2",config=>
            {
                config.BaseAddress= new Uri("http://client_2.com");
                config.DefaultRequestHeaders.Add("header_2","header_2");
            }).SetHandlerLifetime(TimeSpan.FromMinutes(5));;
            services.AddHttpClient();

            //other codes
            services.AddMvc().AddFluentValidation();
        }
      }

public class TestController : ControllerBase
    {
        private readonly IHttpClientFactory _httpClient;
        public TestController(IHttpClientFactory httpClient)
        {
            _httpClient = httpClient;
        }

        public async Task<ActionResult> Test()
        {
            var client = _httpClient.CreateClient("client_1"); //Reuse in Startup Defined in client_1 Of httpclient
            var result = await client.GetStringAsync("/page1.html");

            var client2 = _httpClient.CreateClient(); //Create a new one HttpClient
            var result2 = await client.GetStringAsync("http://www.site.com/XXX.html");

            return null;
        }
    }

public class SampleClient
{
    public HttpClient Client { get; private set; }
    
    public SampleClient(HttpClient httpClient)
    {
        httpClient.BaseAddress = new Uri("https://api.SampleClient.com/");
        httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
        httpClient.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
        Client = httpClient;
    }
}

services.AddHttpClient<SampleClient>();

public class ValuesController : Controller
{
    private readonly SampleClient  _sampleClient;;
  
    public ValuesController(SampleClient  sampleClient)
    {
        _sampleClient = sampleClient;
    }
  
    [HttpGet]
    public async Task<ActionResult> Get()
    {
        string result = await  _sampleClient.client.GetStringAsync("/");
        return Ok(result);
    }
}

public interface ISampleClient
{
    Task<string> GetData();
}
 
public class SampleClient : ISampleClient
{
    private readonly HttpClient _client;
 
    public SampleClient(HttpClient httpClient)
    {
        httpClient.BaseAddress = new Uri("https://api.SampleClient.com/");
        httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
        httpClient.DefaultRequestHeaders.Add("User-Agent", "HttpClientFactory-Sample");
        _client = httpClient;
    }
 
    public async Task<string> GetData()
    {
        return await _client.GetStringAsync("/");
    }
}

services.AddHttpClient<ISampleClient, SampleClient>();

public class ValuesController : Controller
{
    private readonly ISampleClient  _sampleClient;;
     
    public ValuesController(ISampleClient  sampleClient)
    {
        _sampleClient = sampleClient;
    }
     
    [HttpGet]
    public async Task<ActionResult> Get()
    {
        string result = await _sampleClient.GetData();
        return Ok(result);
    }
}

HttpClientFactory advanced

public class RequestIdDelegatingHandler : DelegatingHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            //Process request
            request.Headers.Add("x-guid", Guid.NewGuid().ToString());

            var result = await base.SendAsync(request, cancellationToken); //Call internal handler

            //Process response

            return result;
       

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().AddControllersAsServices();

            services.AddHttpClient();
            services.AddScoped<OrderServiceClient>();
            services.AddSingleton<RequestIdDelegatingHandler>();
            services.AddHttpClient("NamedOrderServiceClient", client =>
            {
                client.DefaultRequestHeaders.Add("client-name", "namedclient");
                client.BaseAddress = new Uri("https://localhost:5003");
            }).SetHandlerLifetime(TimeSpan.FromMinutes(20))
            .AddHttpMessageHandler(provider => provider.GetService<RequestIdDelegatingHandler>());
            

            services.AddScoped<NamedOrderServiceClient>();
            services.AddHttpClient<TypedOrderServiceClient>(client =>
            {
                client.BaseAddress = new Uri("https://localhost:5003");
            });

        }

public void ConfigureServices(IServiceCollection services)
        {
            services.AddMvc().AddControllersAsServices();

            services.AddHttpClient();
            services.AddScoped<OrderServiceClient>();
            services.AddSingleton<RequestIdDelegatingHandler>();
            services.AddHttpClient("NamedOrderServiceClient", client =>
            {
                client.DefaultRequestHeaders.Add("client-name", "namedclient");
                client.BaseAddress = new Uri("https://localhost:5003");
            }).SetHandlerLifetime(TimeSpan.FromMinutes(20))
            .AddHttpMessageHandler(provider => provider.GetService<RequestIdDelegatingHandler>());
            

            services.AddScoped<NamedOrderServiceClient>();
            services.AddHttpClient<TypedOrderServiceClient>(client =>
            {
                client.BaseAddress = new Uri("https://localhost:5003");
            });

        }

Introduction to proto file

Server definition

syntax = "proto3";

option csharp_namespace = "GrpcServer";

package orderser;

service OrderGrpc {
    rpc CreateOrder(CreateOrderCommand) returns (CreateOrderResult);
}


message CreateOrderCommand {
    string buyerId = 1;
    int32 productId = 2;
    double unitPrice = 3;
    double discount = 4;
    int32 units = 5;
}

message CreateOrderResult {
    int32 orderId = 1;
}

public class OrderService : OrderGrpc.OrderGrpcBase
    {
        private readonly ILogger<GreeterService> _logger;
        public OrderService(ILogger<GreeterService> logger)
        {
            _logger = logger;
        }

        public override Task<CreateOrderResult> CreateOrder(CreateOrderCommand request, ServerCallContext context)
        {
            throw new System.Exception("order error");

            //Add the internal logic of order creation, input and store the order information in the database
            return Task.FromResult(new CreateOrderResult { OrderId = 24 });
        }
    }

public void ConfigureServices(IServiceCollection services)
        {
            services.AddGrpc(
                option => {
                    //Production environment shut down
                    option.EnableDetailedErrors = false;
                    //Exception Interceptor 
                    option.Interceptors.Add<ExceptionInterceptor>();
                }
                );
        }

app.UseEndpoints(endpoints =>
            {
                //Endpoint map
                endpoints.MapGrpcService<GreeterService>();
                endpoints.MapGrpcService<OrderService>();

                endpoints.MapGet("/", async context =>
                {
                    await context.Response.WriteAsync("Communication with gRPC endpoints must be made through a gRPC client. To learn how to create a client, visit: https://go.microsoft.com/fwlink/?linkid=2086909");
                });
            });

Client definition