简短的回答:不，目前接受的答案中的陈述是不准确的:“普遍的共识是您不(不应该)需要处理HttpClient”。

长话短说:以下两种说法都是正确的，同时也是可以实现的:

引用自官方文档的“HttpClient旨在被实例化一次，并在应用程序的整个生命周期中被重用”。 一个IDisposable对象被假定/建议被释放。

而且它们彼此之间并不必然冲突。这只是你如何组织你的代码来重用HttpClient并且仍然正确地处理它的问题。

从我的另一个回答中引用了一个更长的回答:

见到人不是巧合 在一些博客文章中指责HttpClient的IDisposable接口 使他们倾向于使用using (var client = new HttpClient()){…}模式 然后导致套接字处理程序耗尽的问题。

我认为这可以归结为一个未说出口的(错误的)概念: “一个IDisposable对象预期是短命的”。

然而，当我们以这种风格编写代码时，它确实看起来像一个短命的东西:

using (var foo = new SomeDisposableObject())
{
    ...
}

IDisposable的官方文件 从来没有提到IDisposable对象必须是短命的。 根据定义，IDisposable只是一种允许您释放非托管资源的机制。 仅此而已。从这个意义上说，你最终会触发处置， 但它并不要求你在短时间内这样做。

因此，正确选择何时触发处置是你的工作， 基于真实对象的生命周期需求。 没有什么能阻止你长久地使用一次性卫生纸:

using System;
namespace HelloWorld
{
    class Hello
    {
        static void Main()
        {
            Console.WriteLine("Hello World!");

            using (var client = new HttpClient())
            {
                for (...) { ... }  // A really long loop

                // Or you may even somehow start a daemon here

            }

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

With this new understanding, now we revisit that blog post, we can clearly notice that the "fix" initializes HttpClient once but never dispose it, that is why we can see from its netstat output that, the connection remains at ESTABLISHED state which means it has NOT been properly closed. If it were closed, its state would be in TIME_WAIT instead. In practice, it is not a big deal to leak only one connection open after your entire program ends, and the blog poster still see a performance gain after the fix; but still, it is conceptually incorrect to blame IDisposable and choose to NOT dispose it.

如果你想要释放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（new Uri（“base url”））.

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

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

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;

在我的例子中，我在一个实际执行服务调用的方法中创建了一个HttpClient。喜欢的东西:

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

在Azure工作人员角色中，在反复调用该方法之后(没有处理HttpClient)，它最终会以SocketException失败(连接尝试失败)。

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

简短的回答:不，目前接受的答案中的陈述是不准确的:“普遍的共识是您不(不应该)需要处理HttpClient”。

长话短说:以下两种说法都是正确的，同时也是可以实现的:

引用自官方文档的“HttpClient旨在被实例化一次，并在应用程序的整个生命周期中被重用”。 一个IDisposable对象被假定/建议被释放。

而且它们彼此之间并不必然冲突。这只是你如何组织你的代码来重用HttpClient并且仍然正确地处理它的问题。

从我的另一个回答中引用了一个更长的回答:

见到人不是巧合 在一些博客文章中指责HttpClient的IDisposable接口 使他们倾向于使用using (var client = new HttpClient()){…}模式 然后导致套接字处理程序耗尽的问题。

我认为这可以归结为一个未说出口的(错误的)概念: “一个IDisposable对象预期是短命的”。

然而，当我们以这种风格编写代码时，它确实看起来像一个短命的东西:

using (var foo = new SomeDisposableObject())
{
    ...
}

IDisposable的官方文件 从来没有提到IDisposable对象必须是短命的。 根据定义，IDisposable只是一种允许您释放非托管资源的机制。 仅此而已。从这个意义上说，你最终会触发处置， 但它并不要求你在短时间内这样做。

因此，正确选择何时触发处置是你的工作， 基于真实对象的生命周期需求。 没有什么能阻止你长久地使用一次性卫生纸:

using System;
namespace HelloWorld
{
    class Hello
    {
        static void Main()
        {
            Console.WriteLine("Hello World!");

            using (var client = new HttpClient())
            {
                for (...) { ... }  // A really long loop

                // Or you may even somehow start a daemon here

            }

            // Keep the console window open in debug mode.
            Console.WriteLine("Press any key to exit.");
            Console.ReadKey();
        }
    }
}

With this new understanding, now we revisit that blog post, we can clearly notice that the "fix" initializes HttpClient once but never dispose it, that is why we can see from its netstat output that, the connection remains at ESTABLISHED state which means it has NOT been properly closed. If it were closed, its state would be in TIME_WAIT instead. In practice, it is not a big deal to leak only one connection open after your entire program ends, and the blog poster still see a performance gain after the fix; but still, it is conceptually incorrect to blame IDisposable and choose to NOT dispose it.

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

请阅读下面我对一个非常类似的问题的回答。很明显，您应该将HttpClient实例视为单例，并在请求之间重用。

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