.NET 6中为每个请求配置不同WebProxy的HttpClient使用方案咨询

问题解答 #

1. 是否应在.NET 6中使用HttpClient？ #

必须用。HttpClient是.NET 6官方主推的HTTP客户端，异步支持完善、性能优异、生态成熟，完全能适配「每个请求用不同代理+多线程并发」的需求，没必要因为代理问题避开它。

2. 为每个请求创建新HttpClient实例是否正确？ #

完全不正确。频繁创建HttpClient实例会快速耗尽系统Socket资源，引发连接超时、资源不足等问题。

你修改Proxy属性无效的原因是：HttpClient初始化后，内部的HttpMessageHandler（比如HttpClientHandler或SocketsHttpHandler）是不可变状态，Proxy是Handler的属性，实例创建后修改Handler的配置不会生效。

正确思路不是创建新HttpClient，而是复用HttpClient的同时，为不同代理匹配对应的Handler，或动态设置代理逻辑。

3. 若不使用HttpClient，应选何种替代方案？ #

不推荐避开HttpClient。如果坚持，只能继续使用已被.NET标记为过时的HttpWebRequest（也就是你当前RestSharp v106依赖的底层实现），但长期来看存在API废弃、维护成本高、性能差的问题。其他基于底层Socket的第三方库生态远不如HttpClient，没必要折腾。

最优方案推荐 #

根据你的场景（多线程+每个请求可能用不同代理），推荐两种方案：

方案一：缓存不同代理对应的HttpClient实例（适合代理重复使用的场景） #

如果部分代理会被多次请求复用，可以用ConcurrentDictionary缓存每个代理对应的HttpClient实例，避免重复创建资源：

using System.Collections.Concurrent;
using System.Net;

// 全局缓存，单例维护
private static readonly ConcurrentDictionary<string, HttpClient> _proxyClientCache = new();

public static HttpClient GetHttpClientForProxy(WebProxy proxy)
{
    // 生成唯一缓存键，包含代理地址和认证信息（避免相同地址不同认证的冲突）
    var cacheKey = $"{proxy.Address}-{proxy.Credentials?.UserName ?? string.Empty}";
    
    return _proxyClientCache.GetOrAdd(cacheKey, key =>
    {
        var handler = new HttpClientHandler
        {
            Proxy = proxy,
            UseProxy = true,
            // 根据业务需求配置其他Handler属性，比如自动重定向、证书验证等
            AllowAutoRedirect = true
        };
        
        return new HttpClient(handler);
    });
}

// 多线程场景下调用示例
var proxy1 = new WebProxy("http://proxy1:8080", false, null, new NetworkCredential("user1", "pass1"));
var client1 = GetHttpClientForProxy(proxy1);
var response1 = await client1.GetAsync("https://example.com");

var proxy2 = new WebProxy("http://proxy2:8080");
var client2 = GetHttpClientForProxy(proxy2);
var response2 = await client2.GetAsync("https://example.com");

这个方案的核心是复用HttpClientHandler（重量级资源）和HttpClient（轻量级），既满足可变代理需求，又避免Socket资源浪费。

方案二：用SocketsHttpHandler动态设置代理（适合代理完全不固定的场景） #

如果每个请求的代理都可能不一样，且几乎没有重复，可以通过SocketsHttpHandler的ConnectCallback动态为每个请求指定代理，全程复用同一个HttpClient实例：

using System.Net;
using System.Net.Sockets;
using System.Text;

// 初始化一次，全局复用
var socketHandler = new SocketsHttpHandler
{
    ConnectCallback = async (context, cancellationToken) =>
    {
        // 从请求属性中取出当前请求需要的代理
        if (context.Properties.TryGetValue("RequestProxy", out var proxyObj) && proxyObj is WebProxy proxy)
        {
            var proxyEndPoint = new DnsEndPoint(proxy.Address.Host, proxy.Address.Port);
            using var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            
            try
            {
                // 连接代理服务器
                await socket.ConnectAsync(proxyEndPoint, cancellationToken);
                
                // 处理代理认证（如果需要）
                if (!string.IsNullOrEmpty(proxy.Credentials?.UserName))
                {
                    var creds = proxy.Credentials as NetworkCredential;
                    var authBase64 = Convert.ToBase64String(Encoding.ASCII.GetBytes($"{creds.UserName}:{creds.Password}"));
                    var connectRequest = $"CONNECT {context.DnsEndPoint.Host}:{context.DnsEndPoint.Port} HTTP/1.1\r\nHost: {context.DnsEndPoint.Host}:{context.DnsEndPoint.Port}\r\nProxy-Authorization: Basic {authBase64}\r\n\r\n";
                    
                    await socket.SendAsync(Encoding.ASCII.GetBytes(connectRequest), SocketFlags.None, cancellationToken);
                    
                    // 读取代理响应，验证连接是否成功
                    var responseBuffer = new byte[1024];
                    var bytesRead = await socket.ReceiveAsync(responseBuffer, SocketFlags.None, cancellationToken);
                    var proxyResponse = Encoding.ASCII.GetString(responseBuffer, 0, bytesRead);
                    
                    if (!proxyResponse.StartsWith("HTTP/1.1 200"))
                    {
                        throw new HttpRequestException($"代理连接失败: {proxyResponse}");
                    }
                }
                
                // 将Socket关联到请求上下文
                context.Stream = new NetworkStream(socket, true);
            }
            catch
            {
                socket.Dispose();
                throw;
            }
        }
        else
        {
            // 无代理时直接连接目标服务器
            using var socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            try
            {
                await socket.ConnectAsync(context.DnsEndPoint, cancellationToken);
                context.Stream = new NetworkStream(socket, true);
            }
            catch
            {
                socket.Dispose();
                throw;
            }
        }
    }
};

// 全局复用这个HttpClient实例
var httpClient = new HttpClient(socketHandler);

// 多线程场景下发送请求示例
var request1 = new HttpRequestMessage(HttpMethod.Get, "https://example.com");
request1.Properties["RequestProxy"] = new WebProxy("http://proxy1:8080", false, null, new NetworkCredential("user1", "pass1"));
var response1 = await httpClient.SendAsync(request1);

var request2 = new HttpRequestMessage(HttpMethod.Post, "https://api.example.com");
request2.Properties["RequestProxy"] = new WebProxy("http://proxy2:8080");
var response2 = await httpClient.SendAsync(request2);

这个方案全程复用一个HttpClient和Handler，通过请求属性传递代理信息，动态处理连接逻辑，完全适配每个请求不同代理的场景，且资源利用率最高。

内容的提问来源于stack exchange，提问作者Xujin.Dai