C#单实例HttpClient如何为每个请求配置不同Proxy？

这问题问得好！用单实例HttpClient避免资源泄漏是正确的做法，但要给每个请求配不同代理确实需要点技巧——毕竟默认情况下HttpClient的代理是全局设置的。下面我给你两种靠谱的实现方式，都是线程安全且符合单实例原则的：

方法一：用自定义DelegatingHandler动态切换代理（简单易实现） #

这种方法通过在请求的属性里携带代理信息，然后用一个自定义的委托处理器在发送请求前临时替换代理，请求完成后恢复原状，兼顾简洁性和安全性。

步骤1：实现自定义的代理委托处理器 #

public class PerRequestProxyHandler : DelegatingHandler
{
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, 
        CancellationToken cancellationToken)
    {
        // 从请求属性中取出预先设置的代理
        if (request.Properties.TryGetValue("PerRequestProxy", out var proxyObj) 
            && proxyObj is WebProxy targetProxy)
        {
            if (InnerHandler is SocketsHttpHandler socketsHandler)
            {
                // 保存原代理设置，避免影响其他并发请求
                var originalProxy = socketsHandler.Proxy;
                try
                {
                    // 临时设置当前请求的代理
                    socketsHandler.Proxy = targetProxy;
                    return await base.SendAsync(request, cancellationToken);
                }
                finally
                {
                    // 请求完成后立即恢复原代理
                    socketsHandler.Proxy = originalProxy;
                }
            }
            // 如果是.NET Framework环境，换成HttpClientHandler的判断逻辑
            else if (InnerHandler is HttpClientHandler httpClientHandler)
            {
                var originalProxy = httpClientHandler.Proxy;
                try
                {
                    httpClientHandler.Proxy = targetProxy;
                    return await base.SendAsync(request, cancellationToken);
                }
                finally
                {
                    httpClientHandler.Proxy = originalProxy;
                }
            }
        }

        // 没有指定代理时，用默认逻辑发送请求
        return await base.SendAsync(request, cancellationToken);
    }
}

步骤2：创建单实例HttpClient #

把自定义处理器挂载到HttpClient的处理器链上，确保全局只用这一个HttpClient实例：

// 初始化单实例HttpClient，.NET Core/.NET 5+推荐用SocketsHttpHandler（性能更优）
var httpClient = new HttpClient(
    new PerRequestProxyHandler 
    { 
        InnerHandler = new SocketsHttpHandler()
        // InnerHandler = new HttpClientHandler() // .NET Framework环境用这个
    });

步骤3：发送带自定义代理的请求 #

每个请求创建HttpRequestMessage时，把代理信息放到属性里即可，支持代理认证：

// 1. 创建目标请求
var request = new HttpRequestMessage(HttpMethod.Get, "https://your-target-resource.com");

// 2. 配置当前请求专属的代理
var customProxy = new WebProxy("http://your-proxy-ip:port")
{
    Credentials = new NetworkCredential("proxy-username", "proxy-password")
};
request.Properties.Add("PerRequestProxy", customProxy);

// 3. 发送请求并处理响应
var response = await httpClient.SendAsync(request);
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync();

⚠️ 注意：这种方法的核心是用try-finally确保代理设置被及时恢复，避免并发请求互相干扰，必须保证HttpClient是全局单实例。

方法二：用SocketsHttpHandler的ConnectCallback（更灵活，适合复杂场景） #

如果你的代理逻辑更复杂（比如需要动态选择代理池、处理特殊认证协议），可以用SocketsHttpHandler的ConnectCallback手动处理连接逻辑，完全控制每个请求的代理路径。

步骤1：初始化带自定义连接逻辑的SocketsHttpHandler #

var socketsHandler = new SocketsHttpHandler();
socketsHandler.ConnectCallback = async (context, cancellationToken) =>
{
    // 从请求属性中获取代理信息
    if (context.RequestMessage.Properties.TryGetValue("PerRequestProxy", out var proxyObj)
        && proxyObj is WebProxy targetProxy)
    {
        // 1. 建立到代理服务器的连接
        var proxyEndpoint = new DnsEndPoint(
            targetProxy.Address.Host, 
            targetProxy.Address.Port);
        var proxySocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
        
        try
        {
            await proxySocket.ConnectAsync(proxyEndpoint, cancellationToken);

            // 2. 如果代理需要认证，发送CONNECT请求并处理授权
            if (targetProxy.Credentials != null)
            {
                var credential = targetProxy.Credentials.GetCredential(
                    targetProxy.Address, 
                    "Basic");
                if (credential != null)
                {
                    var authToken = Convert.ToBase64String(
                        Encoding.ASCII.GetBytes($"{credential.UserName}:{credential.Password}"));
                    var connectRequest = $"CONNECT {context.DnsEndPoint.Host}:{context.DnsEndPoint.Port} HTTP/1.1\r\n" +
                                        $"Host: {context.DnsEndPoint.Host}:{context.DnsEndPoint.Port}\r\n" +
                                        $"Proxy-Authorization: Basic {authToken}\r\n\r\n";
                    
                    await proxySocket.SendAsync(
                        Encoding.ASCII.GetBytes(connectRequest), 
                        SocketFlags.None, 
                        cancellationToken);

                    // 验证代理响应是否成功
                    var buffer = new byte[1024];
                    var bytesRead = await proxySocket.ReceiveAsync(buffer, SocketFlags.None, cancellationToken);
                    var proxyResponse = Encoding.ASCII.GetString(buffer, 0, bytesRead);
                    if (!proxyResponse.StartsWith("HTTP/1.1 200"))
                    {
                        throw new HttpRequestException($"Proxy connection failed: {proxyResponse}");
                    }
                }
            }

            // 3. 返回连接到目标服务器的流
            return new NetworkStream(proxySocket, ownsSocket: true);
        }
        catch
        {
            proxySocket.Dispose();
            throw;
        }
    }

    // 没有代理时，用默认方式连接目标服务器
    var defaultSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
    try
    {
        await defaultSocket.ConnectAsync(context.DnsEndPoint, cancellationToken);
        return new NetworkStream(defaultSocket, ownsSocket: true);
    }
    catch
    {
        defaultSocket.Dispose();
        throw;
    }
};

步骤2：创建单实例HttpClient #

var httpClient = new HttpClient(socketsHandler);

步骤3：发送带代理的请求 #

和方法一完全一致，把代理信息放到请求属性里即可：

var request = new HttpRequestMessage(HttpMethod.Get, "https://your-target-resource.com");
var customProxy = new WebProxy("http://another-proxy:port");
request.Properties.Add("PerRequestProxy", customProxy);

var response = await httpClient.SendAsync(request);

这种方法的优势是完全掌控连接过程，适合需要处理代理跳转、NTLM认证等特殊场景，而且每个请求的连接都是独立的，天然线程安全。

最后再划几个重点：

• 务必保持HttpClient单实例，避免频繁创建导致的Socket资源泄漏。
• 永远不要直接修改全局HttpClient的代理设置，而是通过请求级别的属性传递代理信息。
• 并发场景下一定要注意线程安全，两种方法都已经帮你做好了防护。

内容的提问来源于stack exchange，提问作者Oleksandr Hnatenko