C#如何正确传递HttpRequestMessage与返回HttpResponseMessage避免资源泄漏

基础概念解答 #

• 对象传递/返回的本质
  HttpRequestMessage和HttpResponseMessage均为引用类型，C#中对引用类型的传参、返回操作都只会复制对象的引用地址，不会复制堆上的实际对象，也不存在C++中的移动语义。你从RunCallWithAuth返回的HttpResponseMessage就是SendAsync创建的原始对象，没有额外副本生成。

• 资源释放规则
  IDisposable类型的资源释放遵循「谁最后使用，谁负责释放」的原则：

1. RunCallWithAuth内部不需要释放返回给上层的HttpResponseMessage，因为返回后上层还需要读取响应内容
2. 上层调用方拿到响应后，用using语句包裹即可自动释放资源
3. RunCallWithAuth内部产生的、不会返回给上层的HttpResponseMessage（比如第一次401返回的响应）必须手动释放，避免资源泄漏。

现有代码的隐藏问题修正 #

当前实现存在两个严重的逻辑问题：

1. HttpRequestMessage是一次性对象，仅允许调用一次SendAsync发送，重复发送同一个实例会抛出InvalidOperationException
2. 401重试时直接添加token头会导致同一个头存在两个值，而不是替换原有旧token

修正后的RunCallWithAuth参考实现如下：

// 调整参数为构造request的委托，重试时可以生成新的request实例
public async Task<HttpResponseMessage> RunCallWithAuth(Func<HttpRequestMessage> requestFactory)
{
    // 第一次请求
    var firstRequest = requestFactory();
    firstRequest.Headers.TryAddWithoutValidation("token", getToken());
    using var firstResponse = await client.SendAsync(firstRequest);
    
    if (firstResponse.StatusCode != System.Net.HttpStatusCode.Unauthorized)
    {
        // 把要返回的响应的所有权转移出来，不被当前using释放
        firstResponse.Dispose(false);
        return firstResponse;
    }

    // 401走刷新逻辑
    if (!Refresh())
    {
        throw new IOException("Could not authenticate");
    }

    // 重试生成新的request
    var secondRequest = requestFactory();
    secondRequest.Headers.TryAddWithoutValidation("token", getToken());
    var secondResponse = await client.SendAsync(secondRequest);
    
    if (secondResponse.StatusCode == System.Net.HttpStatusCode.Unauthorized)
    {
        // 重试也失败，先释放响应再抛异常
        secondResponse.Dispose();
        throw new IOException("Could not authenticate");
    }

    return secondResponse;
}

对应的上层调用调整为：

public async Task<string> CallCreateJob()
{
    using var getRequestResponse = await RunCallWithAuth(() => 
    {
        var request = new HttpRequestMessage(HttpMethod.Post, URL);
        request.Content = new StringContent("some content");
        return request;
    });
    return await getRequestResponse.Content.ReadAsStringAsync();
}

场景标准最佳实践 #

处理带认证重试的HTTP请求，.NET生态的标准方案是使用DelegatingHandler自定义消息处理器，直接嵌入HttpClient的请求管道，上层业务代码完全不需要感知认证、重试逻辑：

public class AuthHandler : DelegatingHandler
{
    // 省略token相关逻辑和构造函数
    protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        request.Headers.TryAddWithoutValidation("token", getToken());
        var response = await base.SendAsync(request, cancellationToken);
        
        if (response.StatusCode != HttpStatusCode.Unauthorized)
            return response;
        
        response.Dispose();
        if (!Refresh())
            throw new IOException("Could not authenticate");
        
        // 重试需要克隆请求，避免重复发送原始request
        var retryRequest = request.Clone();
        retryRequest.Headers.TryAddWithoutValidation("token", getToken());
        response = await base.SendAsync(retryRequest, cancellationToken);

        if (response.StatusCode == HttpStatusCode.Unauthorized)
        {
            response.Dispose();
            throw new IOException("Could not authenticate");
        }

        return response;
    }
}

注：HttpRequestMessage.Clone为.NET 5+ 提供的扩展方法，低版本框架可以替换为传入请求构造委托的方案实现重试。
使用时只需在构造HttpClient时注入这个处理器即可：

var httpClient = new HttpClient(new AuthHandler())
{
    BaseAddress = new Uri("你的API地址")
};

之后直接用这个httpClient发送普通请求，会自动带上认证逻辑和重试能力。

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