必须在请求之间处理HttpClient和HttpClientHandler吗

dispose((调用下面的代码，关闭HttpClient实例打开的连接。该代码是通过使用dotPeek反编译创建的。

HttpClientHandler.cs-处理

ServicePointManager.CloseConnectionGroups(this.connectionGroupName);

如果不调用dispose，则由计时器运行的ServicePointManager.MaxServicePointIdleTime将关闭http连接。默认值为100秒。

ServicePointManager.cs

internal static readonly TimerThread.Callback s_IdleServicePointTimeoutDelegate = new TimerThread.Callback(ServicePointManager.IdleServicePointTimeoutCallback);
private static volatile TimerThread.Queue s_ServicePointIdlingQueue = TimerThread.GetOrCreateQueue(100000);
private static void IdleServicePointTimeoutCallback(TimerThread.Timer timer, int timeNoticed, object context)
{
  ServicePoint servicePoint = (ServicePoint) context;
  if (Logging.On)
    Logging.PrintInfo(Logging.Web, SR.GetString("net_log_closed_idle", (object) "ServicePoint", (object) servicePoint.GetHashCode()));
  lock (ServicePointManager.s_ServicePointTable)
    ServicePointManager.s_ServicePointTable.Remove((object) servicePoint.LookupString);
  servicePoint.ReleaseAllConnectionGroups();
}

如果你还没有将空闲时间设置为无限，那么不调用dispose并让空闲连接计时器启动并为你关闭连接似乎是安全的，尽管如果你知道你已经完成了HttpClient实例并更快地释放资源，那么最好在using语句中调用dispose。

在我的案例中，我在一个实际执行服务调用的方法中创建了一个HttpClient。类似于：

public void DoServiceCall() {
  var client = new HttpClient();
  await client.PostAsync();
}

在Azure工作者角色中，在重复调用此方法(不处理HttpClient(后，它最终会以SocketException失败(连接尝试失败(。

我将HttpClient作为一个实例变量(在类级别处理它(，问题就消失了。所以我想说，是的，处理HttpClient，假设它是安全的(你没有未完成的异步调用(。

在典型的用法(responses<2GB(中，没有必要处理HttpResponseMessages。

如果HttpClient方法的流内容不是完全读取的，则应处理其返回类型。否则，CLR无法知道这些流可以关闭，直到它们被垃圾收集。

• 如果将数据读取到byte[](例如GetByteArrayAsync(或字符串中，则会读取所有数据，因此无需进行处理
• 其他重载将默认为读取高达2GB的流(HttpCompletionOption为ResponseContentRead，HttpClient.MaxResponseContent BufferSize默认为2GB(

如果将HttpCompletionOption设置为ResponseHeadersRead或响应大于2GB，则应该进行清理。这可以通过对HttpResponseMessage调用Dispose，或对从HttpResonseMessage内容获得的流调用Dispose/Close，或完全读取内容来完成。

是否在HttpClient上调用Dispose取决于是否要取消挂起的请求。

如果您想处理HttpClient，如果您将其设置为资源池，则可以。在应用程序结束时，您将处理资源池。

代码：

// Notice that IDisposable is not implemented here!
public interface HttpClientHandle
{
    HttpRequestHeaders DefaultRequestHeaders { get; }
    Uri BaseAddress { get; set; }
    // ...
    // All the other methods from peeking at HttpClient
}
public class HttpClientHander : HttpClient, HttpClientHandle, IDisposable
{
    public static ConditionalWeakTable<Uri, HttpClientHander> _httpClientsPool;
    public static HashSet<Uri> _uris;
    static HttpClientHander()
    {
        _httpClientsPool = new ConditionalWeakTable<Uri, HttpClientHander>();
        _uris = new HashSet<Uri>();
        SetupGlobalPoolFinalizer();
    }
    private DateTime _delayFinalization = DateTime.MinValue;
    private bool _isDisposed = false;
    public static HttpClientHandle GetHttpClientHandle(Uri baseUrl)
    {
        HttpClientHander httpClient = _httpClientsPool.GetOrCreateValue(baseUrl);
        _uris.Add(baseUrl);
        httpClient._delayFinalization = DateTime.MinValue;
        httpClient.BaseAddress = baseUrl;
        return httpClient;
    }
    void IDisposable.Dispose()
    {
        _isDisposed = true;
        GC.SuppressFinalize(this);
        base.Dispose();
    }
    ~HttpClientHander()
    {
        if (_delayFinalization == DateTime.MinValue)
            _delayFinalization = DateTime.UtcNow;
        if (DateTime.UtcNow.Subtract(_delayFinalization) < base.Timeout)
            GC.ReRegisterForFinalize(this);
    }
    private static void SetupGlobalPoolFinalizer()
    {
        AppDomain.CurrentDomain.ProcessExit +=
            (sender, eventArgs) => { FinalizeGlobalPool(); };
    }
    private static void FinalizeGlobalPool()
    {
        foreach (var key in _uris)
        {
            HttpClientHander value = null;
            if (_httpClientsPool.TryGetValue(key, out value))
                try { value.Dispose(); } catch { }
        }
        _uris.Clear();
        _httpClientsPool = null;
    }
}

var handler=HttpClientHander.GetHttpClientHandle(新的Uri("基本url"((。

• HttpClient作为一个接口，不能调用Dispose((
• Dispose((将由垃圾回收器以延迟的方式调用。或者当程序通过其析构函数清理对象时
• 使用弱引用+延迟清理逻辑，因此只要它经常被重用，它就会一直使用
• 它只为传递给它的每个基本URL分配一个新的HttpClient。原因由Ohad Schneider解释如下。更改基本url时出现错误行为
• HttpClientHandle允许在测试中进行模拟

在构造函数中使用依赖项注入可以更容易地管理HttpClient的生命周期-将生命周期管理置于需要它的代码之外，并使它在以后可以轻松更改。

我目前的偏好是为每个目标端点域创建一个从HttpClient继承一次的单独http客户端类，然后使用依赖注入使其成为单例。public class ExampleHttpClient : HttpClient { ... }

然后，我在需要访问API的服务类中获取对自定义http客户端的构造函数依赖项。这解决了生存期问题，并且在连接池方面具有优势。

您可以在相关答案中看到一个工作示例https://stackoverflow.com/a/50238944/3140853

不，不要在每个请求上创建一个新请求(即使您处理了旧请求(。您将导致服务器本身(而不仅仅是应用程序(因操作系统上网络级别的端口耗尽而崩溃！

请阅读我对下面发布的一个非常相似的问题的回答。应该清楚的是，您应该将HttpClient实例视为singleton，并在请求之间重复使用。

在WebAPI客户端中每次调用创建一个新的HttpClient的开销是多少？

我认为应该使用singleton模式来避免创建HttpClient实例并一直关闭它。如果您使用的是.Net 4.0，您可以使用下面的示例代码。有关singleton模式检查的更多信息，请点击此处。

class HttpClientSingletonWrapper : HttpClient
{
    private static readonly Lazy<HttpClientSingletonWrapper> Lazy= new Lazy<HttpClientSingletonWrapper>(()=>new HttpClientSingletonWrapper()); 
    public static HttpClientSingletonWrapper Instance {get { return Lazy.Value; }}
    private HttpClientSingletonWrapper()
    {
    }
}

使用如下代码。

var client = HttpClientSingletonWrapper.Instance;