在我的理解中，只有当Dispose()锁定稍后需要的资源(如特定连接)时才有必要调用Dispose()。总是建议释放你不再使用的资源，即使你不再需要它们，只是因为你通常不应该持有你不使用的资源。

微软的例子不一定是错误的。当应用程序退出时，将释放所使用的所有资源。在那个例子中，它几乎是在HttpClient被使用完之后立即发生的。在类似的情况下，显式调用Dispose()有点多余。

但是，一般来说，当一个类实现IDisposable时，只要您完全准备好并能够执行，您就应该Dispose()它的实例。我认为在像HttpClient这样的情况下尤其如此，其中没有明确地记录资源或连接是否被保持/打开。在连接将[很快]再次被重用的情况下，您将希望放弃它的dispose()处理——在这种情况下，您还没有“完全准备好”。

参见: IDisposable。Dispose方法和何时调用Dispose

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

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

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

因为似乎还没有人在这里提到它，在。net Core >=2.1和。net 5.0+中管理HttpClient和HttpClientHandler的最佳新方法是使用HttpClientFactory。

它以一种干净和易于使用的方式解决了上述大多数问题和陷阱。摘自Steve Gordon的博客文章:

将以下包添加到.Net Core(2.1.1或更高版本)项目中:

Microsoft.AspNetCore.All
Microsoft.Extensions.Http

将此添加到Startup.cs:

services.AddHttpClient();

注射使用:

[Route("api/[controller]")]
public class ValuesController : Controller
{
    private readonly IHttpClientFactory _httpClientFactory;

    public ValuesController(IHttpClientFactory httpClientFactory)
    {
        _httpClientFactory = httpClientFactory;
    }

    [HttpGet]
    public async Task<ActionResult> Get()
    {
        var client = _httpClientFactory.CreateClient();
        var result = await client.GetStringAsync("http://www.google.com");
        return Ok(result);
    }
}

探索Steve博客中的系列文章，了解更多功能。

我认为应该使用单例模式来避免创建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，你可以把它设置为一个资源池。在应用程序的末尾，分配资源池。

代码:

// 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。喜欢的东西:

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

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

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