.Net HttpClient 使用准则

HttpClient 使用准则

System.Net.Http.HttpClient 类用于发送 HTTP 请求以及从 URI 所标识的资源接收 HTTP 响应。 HttpClient 实例是应用于该实例执行的所有请求的设置集合，每个实例使用自身的连接池，该池将其请求与其他请求隔离开来。

从 .NET Core 2.1 开始，SocketsHttpHandler 类提供实现，使行为在所有平台上保持一致。

准备工作：先执行下面单元，以启动WebApi及设置全局对象、方法及其它

//初始化：必须先执行一次
#!import ./ini.ipynb

统一使用示例

{ //大括号: 1、作用域隔离 2、方便整体代码折叠
    Console.WriteLine(global_api_config.BaseUrl);
}

启动WebApi

#启动已发布的WebApi项目
# 使用dotnet命令启动的程序，进程名均为 dotnet，不好关闭
# Start-Process -FilePath dotnet -ArgumentList ".\Publish\HttpClientStudy.WebApp\HttpClientStudy.WebApp.dll"

# 此种，进程名固定
Start-Process -FilePath ".\Publish\HttpClientStudy.WebApp\HttpClientStudy.WebApp.exe"

关闭WebApi

# 关闭项目进程
$WebAppProcName ="HttpClientStudy.WebApp";
$WebAppProc = Get-Process $WebAppProcName -ErrorAction Ignore
if($null -eq $WebAppProc)
{
    Write-Host "进程没有找到，可能已经关闭"
}
else {
    $WebAppProc.Kill();
    Write-Host "$WebAppProcName 进程已退出"
}

1、DNS 行为

HttpClient 仅在创建连接时解析 DNS。它不跟踪 DNS 服务器指定的任何生存时间 (TTL)。

如果 DNS 条目定期更改（这可能在某些方案中发生），客户端将不会遵循这些更新。要解决此问题，可以通过设置 PooledConnectionLifetime 属性来限制连接的生存期，以便在替换连接时重复执行 DNS 查找。

using System.Net.Http;
{
    var handler = new SocketsHttpHandler
    {
        // 15分钟
        PooledConnectionLifetime = TimeSpan.FromMinutes(15) 
    };
    var sharedClient = new HttpClient(handler);

    sharedClient.Display();
}

上述 HttpClient 配置为重复使用连接 15 分钟。 PooledConnectionLifetime 指定的时间范围过后，系统会关闭连接，然后创建一个新连接。

2、共用连接(底层自动管理连接池)

HttpClient 的连接池链接到其基础 SocketsHttpHandler。
释放 HttpClient 实例时，它会释放池中的所有现有连接。如果稍后向同一服务器发送请求，则必须重新创建一个新连接。
因此，创建不必要的连接会导致性能损失。
此外，TCP 端口不会在连接关闭后立即释放。（有关这一点的详细信息，请参阅 RFC 9293 中的 TCP TIME-WAIT。）如果请求速率较高，则可用端口的操作系统限制可能会耗尽。

为了避免端口耗尽问题，建议将 HttpClient 实例重用于尽可能多的 HTTP 请求。

什么是连接池

SocketsHttpHandler为每个唯一端点建立连接池，您的应用程序通过HttpClient向该唯一端点发出出站HTTP请求。在对端点的第一个请求上，当不存在现有连接时，将建立一个新的HTTP连接并将其用于该请求。该请求完成后，连接将保持打开状态并返回到池中。

对同一端点的后续请求将尝试从池中找到可用的连接。如果没有可用的连接，并且尚未达到该端点的连接限制，则将建立新的连接。达到连接限制后，请求将保留在队列中，直到连接可以自由发送它们为止。

如何控制连接池

有三个主要设置可用于控制连接池的行为。

PooledConnectionLifetime，定义连接在池中保持活动状态的时间。此生存期到期后，将不再为将来的请求而合并或发出连接。
PooledConnectionIdleTimeout，定义闲置连接在未使用时在池中保留的时间。一旦此生存期到期，空闲连接将被清除并从池中删除。
MaxConnectionsPerServer，定义每个端点将建立的最大出站连接数。每个端点的连接分别池化。例如，如果最大连接数为2，则您的应用程序将请求发送到两个www.github.com和www.google.com，总共可能最多有4个打开的连接。

默认情况下，从.NET Core 2.1开始，更高级别的HttpClientHandler将SocketsHttpHandler用作内部处理程序。没有任何自定义配置，将应用连接池的默认设置。

该PooledConnectionLifetime默认是无限的，因此，虽然经常使用的请求，连接可能会无限期地保持打开状态。该PooledConnectionIdleTimeout默认为2分钟，如果在连接池中长时间未使用将被清理。MaxConnectionsPerServer默认为int.MaxValue，因此连接基本上不受限制。

如果希望控制这些值中的任何一个，则可以手动创建SocketsHttpHandler实例，并根据需要进行配置。

//手动配置 SocketsHttpHandler
{
	var socketsHandler = new SocketsHttpHandler
	{
		PooledConnectionLifetime = TimeSpan.FromMinutes(10),
		PooledConnectionIdleTimeout = TimeSpan.FromMinutes(5),
		MaxConnectionsPerServer = 10
	};
		
	var client = new HttpClient(socketsHandler);

	client.Display();
}

在前面的示例中，对SocketsHttpHandler进行了配置，以使连接将最多在10分钟后停止重新发出并关闭。如果闲置5分钟，则连接将在池的清理过程中被更早地删除。我们还将最大连接数（每个端点）限制为十个。如果我们需要并行发出更多出站请求，则某些请求可能会排队等待，直到10个池中的连接可用为止。
要应用处理程序，它将被传递到HttpClient的构造函数中。

测试连接寿命

//测试连接寿命
{
    Console.WriteLine("程序运行大约要10-20秒，请在程序退出后，执行下面命令行查看网络情况");

    //自定义行为
    var socketsHandler = new SocketsHttpHandler
    {
        //连接池生命周期为10分钟：连接在池中保持活动时间为10分钟
        PooledConnectionLifetime = TimeSpan.FromMinutes(10),

        //池化链接的空闲超时时间为5分钟: 5分钟内连接不被重用，则被释放后销毁
        PooledConnectionIdleTimeout = TimeSpan.FromMinutes(5),
        
        //每端点的最大连接数设置为10个
        MaxConnectionsPerServer = 10
    };

    var client = new HttpClient(socketsHandler)
    {
        BaseAddress = new Uri(global_api_config.BaseUrl)
    };

    var displayer = "".Display();

    for (var i = 0; i < 5; i++)
    {
        if(i>0)
        {
            await Task.Delay(TimeSpan.FromSeconds(2));
        }
        _ = await client.GetAsync(global_default_page);
        displayer.Update(($"第{i+1}次请求完成"));
        
        await Task.Delay(TimeSpan.FromSeconds(2));
    }
}

使用自定义设置，依次向同一端点发出5个请求。在每个请求之间，暂停两秒钟。输出从DNS检索到的网站服务器的IPv4地址。我们可以使用此IP地址来查看通过PowerShell中发出的netstat命令对其打开的连接：

# 若查询不到，则异常
#!set --value @csharp:global_netstat_filter --name queryFilter

Write-Host "请先执行上面的单元，再执行本单元"
Write-Host "网络状态"
netstat -ano | findstr $queryFilter

在这种情况下，到远程端点的连接只有1个。在每个请求之后，该连接将返回到池中，因此在发出下一个请求时可以重新使用。
如果更改连接的生存期，以使它们在1秒后过期，测试这对行为的影响：

//程序池设置
{  
    //自定义行为
    Console.WriteLine("程序运行大约要10-20，请在程序退出后，执行下面命令行查看网络情况");
    var socketsHandler2 = new SocketsHttpHandler
    {
        PooledConnectionLifetime = TimeSpan.FromSeconds(1),
        PooledConnectionIdleTimeout = TimeSpan.FromSeconds(1),
        MaxConnectionsPerServer = 1
    };

    var client2 = new HttpClient(socketsHandler2)
    {
        BaseAddress = new Uri(global_api_config.BaseUrl)
    };

    var displayer = "".Display();

    for (var i = 0; i < 5; i++)
    {
        if(i>0)
        {
            await Task.Delay(TimeSpan.FromSeconds(2));
        }
        _ = await client2.GetAsync(global_default_page);
        displayer.Update(($"第{i+1}次请求完成"));
        
        await Task.Delay(TimeSpan.FromSeconds(2));
    }
   
    //调用命令行，显示查看网络情况
    string command = $"netstat -ano | findstr {global_netstat_filter}";
    
    // 创建一个新的ProcessStartInfo对象
    ProcessStartInfo startInfo = new ProcessStartInfo("cmd", $"/c {command}")
    {
        RedirectStandardOutput = true, // 重定向标准输出
        UseShellExecute = false, // 不使用系统外壳程序启动
        CreateNoWindow = true // 不创建新窗口
    };
    
    // 启动进程
    using (Process process = Process.Start(startInfo))
    {
        // 读取cmd的输出
        using (StreamReader reader = process.StandardOutput)
        {
            string stdoutLine = reader.ReadToEnd();
            Console.WriteLine(stdoutLine);
        }
    }
}

#!set --value @csharp:global_netstat_filter --name queryFilter
netstat -ano | findstr $queryFilter

在这种情况下，我们可以看到使用了五个连接。其中的前四个在1秒后从池中删除，因此无法在下一个请求中重复使用。结果，每个请求都打开了一个新连接。现在，原始连接处于TIME_WAIT状态，并且操作系统无法将其重新用于新的出站连接。最终连接显示为ESTABLISHED，因为我在它过期之前就抓住了它。

测试最大连接数

/*
	功能：将MaxConnectionsPerServer限制为2。然后启动200个任务，每个任务都向同一端点发出HTTP请求。这些任务将同时运行。所有请求竞争所花费的时间将写入控制台。
		  随即调用用netstat命令查看连接：则根据定义的限制，我们可以看到两个已建立的连接。
*/
{
	Console.WriteLine("开始请求网络...");
	var socketsHandler = new SocketsHttpHandler
	{
		PooledConnectionLifetime = TimeSpan.FromSeconds(60),
		PooledConnectionIdleTimeout = TimeSpan.FromMinutes(20),
		MaxConnectionsPerServer = 2
	};

	var client = new HttpClient(socketsHandler)
	{
		BaseAddress = new Uri(global_api_config.BaseUrl)
	};

	var sw = Stopwatch.StartNew();

	var tasks = Enumerable.Range(0, 200).Select(i => client.GetAsync(global_default_page));

	await Task.WhenAll(tasks);

	sw.Stop();
		
	Console.WriteLine($"共请求了200次，耗时 {sw.ElapsedMilliseconds} 毫秒");
		
	//执行查看网络状态方法
	Console.WriteLine("当前网络状态");
	var message = HttpClientStudy.Core.Utilities.AppUtility.RunCmd($"netstat -ano | findstr {global_netstat_filter}");
	Console.WriteLine(message);
}

# 重新查询当前网络状态
#!set --value @csharp:global_netstat_filter --name queryFilter
netstat -ano | findstr $queryFilter

如果我们调整此代码以允许MaxConnectionsPerServer = 10，则可以重新运行该应用程序。耗时将减少大约4倍。

{   //MaxConnectionsPerServer 设置为10：网络连接将增加到10个，耗时将减少到1/4
	Console.WriteLine("开始请求网络...");
	var socketsHandler = new SocketsHttpHandler
	{
		PooledConnectionLifetime = TimeSpan.FromSeconds(60),
		PooledConnectionIdleTimeout = TimeSpan.FromMinutes(20),
		MaxConnectionsPerServer = 10
	};

	var client = new HttpClient(socketsHandler)
	{
		BaseAddress = new Uri(global_api_config.BaseUrl)
	};

	//client.Display();

	var sw = Stopwatch.StartNew();

	var tasks = Enumerable.Range(0, 200).Select(i => client.GetAsync(global_default_page));

	await Task.WhenAll(tasks);

	sw.Stop();
		
	Console.WriteLine($"共请求了200次，耗时 {sw.ElapsedMilliseconds} 毫秒");
		
	//执行查看网络状态方法
	Console.WriteLine("当前网络状态");
	var message = AppUtility.RunCmd($"netstat -ano | findstr {global_netstat_filter}");
	Console.WriteLine(message);
}

3、推荐使用方式

总则：

一、应使用长期客户端（静态对象、单例等），并设置 PooledConnectionLifetime。这能解决DNS问题和套接字耗尽问题。

二、使用 IHttpClientFactory 创建的短期客户端：

在 .NET Core 和 .NET 5+ 中：
- 根据预期的 DNS 更改，使用 static 或 singletonHttpClient 实例，并将 PooledConnectionLifetime 设置为所需间隔（例如 2 分钟）。这可以解决端口耗尽和 DNS 更改两个问题，而且不会增加 IHttpClientFactory 的开销。如果需要模拟处理程序，可以单独注册它。
- 使用 IHttpClientFactory，可以针对不同的用例使用多个以不同方式配置的客户端。但请注意，工厂创建的客户端生存期较短，一旦创建客户端，工厂就不再可以控制它。
  工厂合并 HttpMessageHandler 实例，如果其生存期尚未过期，则当工厂创建新的 HttpClient 实例时，可以从池中重用处理程序。这种重用避免了任何套接字耗尽问题。
  如果需要 IHttpClientFactory 提供的可配置性，我们建议使用类型化客户端方法。
在 .NET Framework 中，使用 IHttpClientFactory 管理 HttpClient 实例。如果不使用工厂，而是改为自行为每个请求创建新的客户端实例，则可能耗尽可用的端口。

提示: 如果应用需要 Cookie，请考虑禁用自动 Cookie 处理或避免使用 IHttpClientFactory。共用 HttpMessageHandler 实例会导致共享 CookieContainer 对象。意外的 CookieContainer 对象共享通常会导致错误的代码。

{ //不推荐的示例
   int requestCount =0;

    //这会建立10个 HttpClient 
    //尽管使用了Using，不过Using只保证应用进程释放实例；但是http请求是跨操作系统、跨网络的操作，调用Using的进程管不了操作系统，更管不了网络。
    //如果把循环次数加大到 65535 就会一定导致夏套接字耗尽(2000以很可能就会出现)。
   Parallel.For(0,10,async (a,b)=>
   {
        using (var client = new HttpClient())
        {
            _ = await client.GetAsync (global_api_config.BaseUrl + global_default_page);
        }   
        Interlocked.Add(ref requestCount, 1);
    });
}

{ //使用长期客户端
   using (var client = new HttpClient())
   {
        client.BaseAddress = new Uri(global_api_config.BaseUrl);
        
        for(int i=0; i<10; i++)
        {
            //n次调用，均使用同一个 HttpClient 实例
            _ = await client.GetAsync(global_default_page);
        }
   }// 所有调用完成，才释放 HttpClient 实例
}

4、静态客户端的复原能力

#r "nuget:Polly"
#r "nuget:Microsoft.Extensions.Http.Resilience"
using System;
using System.Net.Http;
using Microsoft.Extensions.Http;
using Microsoft.Extensions.Http.Resilience;
using Polly;

{
    var retryPipeline = new ResiliencePipelineBuilder<HttpResponseMessage>()
    .AddRetry(new HttpRetryStrategyOptions
    {
        BackoffType = DelayBackoffType.Exponential,
        MaxRetryAttempts = 3
    })
    .Build();

    var socketHandler = new SocketsHttpHandler
    {
        PooledConnectionLifetime = TimeSpan.FromMinutes(15)
    };

    #pragma warning disable EXTEXP0001
    var resilienceHandler = new ResilienceHandler(retryPipeline)
    {
        InnerHandler = socketHandler,
    };
    #pragma warning restore EXTEXP0001

    var httpClient = new HttpClient(resilienceHandler);
    httpClient.BaseAddress = new Uri(global_api_config.BaseUrl);

    var response = await httpClient.GetAsync(global_default_page);
    var htmlText = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"共有{htmlText.Length}个字符");
}