Do HttpClient and HttpClientHandler have to be disposed between requests

Question

System Net Http HttpClient and System Net Http HttpClientHandler in  NET Framework 4 5 implement IDisposable  via System Net Http HttpMessageInvoker    The using statement documentation says      As a rule  when you use an IDisposable object  you should declare and   instantiate it in a using statement    This answer uses this pattern   var baseAddress   new Uri  http   example com    var cookieContainer   new CookieContainer    using  var handler   new HttpClientHandler     CookieContainer   cookieContainer    using  var client   new HttpClient handler    BaseAddress   baseAddress          var content   new FormUrlEncodedContent new                 new KeyValuePair lt string  string gt   foo    bar            new KeyValuePair lt string  string gt   baz    bazinga                cookieContainer Add baseAddress  new Cookie  CookieName    cookie value         var result   client PostAsync   test   content  Result      result EnsureSuccessStatusCode        But the most visible examples from Microsoft don t call Dispose   either explicitly or implicitly  For instance    The original blog article announcing the relase of HttpClient  The actual MSDN documentation for HttpClient  BingTranslateSample GoogleMapsSample WorldBankSample   In the announcement s comments  someone asked the Microsoft employee      After checking your samples  I saw that you didn t perform the dispose   action on HttpClient instance  I have used all instances of HttpClient   with using statement on my app and I thought that it is the right way   since HttpClient  implements the IDisposable interface  Am I on the   right path    His answer was      In general that is correct although you have to be careful with    using  and async as they dont  really mix in  Net 4  In  Net 4 5 you   can use  await  inside a  using  statement       Btw  you can reuse the same HttpClient as many times are  as  you like so   typically you won t create dispose them all the time    The second paragraph is superfluous to this question  which is not concerned about how many times you can use an HttpClient instance  but about if it is necessary to dispose it after you no longer need it    Update  in fact that second paragraph is the key to the answer  as provided below by  DPeden    So my questions are    Is it necessary  given the current implementation   NET Framework 4 5   to call Dispose   on HttpClient and HttpClientHandler instances  Clarification  by  necessary  I mean if there are any negative consequences for not disposing  such as resource leakage or data corruption risks  If it s not necessary  would it be a  good practice  anyway  since they implement IDisposable  If it s necessary  or recommended   is this code mentioned above implementing it safely  for  NET Framework 4 5   If these classes don t require calling Dispose    why were they implemented as IDisposable  If they require  or if it s a recommended practice  are the Microsoft examples misleading or unsafe

User · Answer

If you want to dispose of HttpClient  you can if you set it up as a resource pool  And at the end of your application  you dispose your resource pool   Code      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 lt Uri  HttpClientHander gt   httpClientsPool      public static HashSet lt Uri gt   uris       static HttpClientHander                  httpClientsPool   new ConditionalWeakTable lt Uri  HttpClientHander gt              uris   new HashSet lt Uri gt             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   lt  base Timeout              GC ReRegisterForFinalize this              private static void SetupGlobalPoolFinalizer                 AppDomain CurrentDomain ProcessExit                 sender  eventArgs    gt    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  as an interface  can t call Dispose    Dispose   will be called in a delayed fashion by the Garbage Collector  Or when the program cleans up the object through its destructor  Uses Weak References   delayed cleanup logic so it remains in use so long as it is being reused frequently  It only allocates a new HttpClient for each base URL passed to it  Reasons explained by Ohad Schneider answer below  Bad behavior when changing base url  HttpClientHandle allows for Mocking in tests

User · Answer

Using dependency injection in your constructor makes managing the lifetime of your HttpClient easier - taking the lifetime managemant outside of the code that needs it and making it easily changable at a later date    My current preference is to create a seperate http client class that inherits from HttpClient once per target endpoint domain and then make it a singleton using dependency injection  public class ExampleHttpClient   HttpClient           Then I take a constructor dependency on the custom http client in the service classes where I need access to that API  This solves the lifetime problem and has advantages when it comes to connection pooling   You can see a worked example in related answer at https   stackoverflow com a 50238944 3140853

User · Answer

Since it doesn t appear that anyone has mentioned it here yet  the new best way to manage HttpClient and HttpClientHandler in  NET Core 2 1 is using HttpClientFactory  It solves most of the aforementioned issues and gotchas in a clean and easy-to-use way   From Steve Gordon s great blog post  Add the following packages to your  Net Core  2 1 1 or later  project  Microsoft AspNetCore All Microsoft Extensions Http  Add this to Startup cs  services AddHttpClient     Inject and use   Route  quot api  controller  quot    public class ValuesController   Controller       private readonly IHttpClientFactory  httpClientFactory       public ValuesController IHttpClientFactory httpClientFactory                 httpClientFactory   httpClientFactory              HttpGet      public async Task lt ActionResult gt  Get                 var client    httpClientFactory CreateClient            var result   await client GetStringAsync  quot http   www google com quot            return Ok result            Explore the series of posts in Steve s blog for lots more features

User · Answer

Please take a read on my answer to a very similar question posted below   It should be clear that you should treat HttpClient instances as singletons and re-used across requests   What is the overhead of creating a new HttpClient per call in a WebAPI client

User · Answer

I think one should use singleton pattern to avoid having to create instances of the HttpClient and closing it all the time  If you are using  Net 4 0 you could use a sample code as below  for more information on singleton pattern check here   class HttpClientSingletonWrapper   HttpClient       private static readonly Lazy lt HttpClientSingletonWrapper gt  Lazy  new Lazy lt HttpClientSingletonWrapper gt      gt new HttpClientSingletonWrapper           public static HttpClientSingletonWrapper Instance  get   return Lazy Value          private HttpClientSingletonWrapper                   Use the code as below   var client   HttpClientSingletonWrapper Instance

User · Answer

The general consensus is that you do not  should not  need to dispose of HttpClient   Many people who are intimately involved in the way it works have stated this   See Darrel Miller s blog post and a related SO post  HttpClient crawling results in memory leak for reference   I d also strongly suggest that you read the HttpClient chapter from Designing Evolvable Web APIs with ASP NET for context on what is going on under the hood  particularly the  Lifecycle  section quoted here      Although HttpClient does indirectly implement the IDisposable   interface  the standard usage of HttpClient is not to dispose of it   after every request  The HttpClient object is intended to live for as   long as your application needs to make HTTP requests  Having an object   exist across multiple requests enables a place for setting   DefaultRequestHeaders and prevents you from having to re-specify   things like CredentialCache and CookieContainer on every request as   was necessary with HttpWebRequest    Or even open up DotPeek

User · Answer

In my understanding  calling Dispose   is necessary only when it s locking resources you need later  like a particular connection   It s always recommended to free resources you re no longer using  even if you don t need them again  simply because you shouldn t generally be holding onto resources you re not using  pun intended    The Microsoft example is not incorrect  necessarily  All resources used will be released when the application exits  And in the case of that example  that happens almost immediately after the HttpClient is done being used  In like cases  explicitly calling Dispose   is somewhat superfluous   But  in general  when a class implements IDisposable  the understanding is that you should Dispose   of its instances as soon as you re fully ready and able  I d posit this is particularly true in cases like HttpClient wherein it s not explicitly documented as to whether resources or connections are being held onto open  In the case wherein the connection will be reused again  soon   you ll want to forgo Dipose  ing of it -- you re not  fully ready  in that case   See also  IDisposable Dispose Method and When to call Dispose

User · Answer

Dispose   calls the code below  which closes the connections opened by the HttpClient instance  The code was created by decompiling with dotPeek   HttpClientHandler cs - Dispose  ServicePointManager CloseConnectionGroups this connectionGroupName     If you don t call dispose then ServicePointManager MaxServicePointIdleTime  which runs by a timer  will close the http connections  The default is 100 seconds   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        If you haven t set the idle time to infinite then it appears safe not to call dispose and let the idle connection timer kick-in and close the connections for you  although it would be better for you to call dispose in a using statement if you know you are done with an HttpClient instance and free up the resources faster

User · Answer

The current answers are a bit confusing and misleading  and they are missing some important DNS implications  I ll try to summarize where things stand clearly    Generally speaking most IDisposable objects should ideally be disposed when you are done with them  especially those that own Named shared OS resources  HttpClient is no exception  since as Darrel Miller points out it allocates cancellation tokens  and request response bodies can be unmanaged streams  However  the best practice for HttpClient says you should create one instance and reuse it as much as possible  using its thread-safe members in multi-threaded scenarios   Therefore  in most scenarios you ll never dispose of it simply because you will be needing it all the time  The problem with re-using the same HttpClient  forever  is that the underlying HTTP connection might remain open against the originally DNS-resolved IP  regardless of DNS changes  This can be an issue in scenarios like blue green deployment and DNS-based failover  There are various approaches for dealing with this issue  the most reliable one involving the server sending out a Connection close header after DNS changes take place  Another possibility involves recycling the HttpClient on the client side  either periodically or via some mechanism that learns about the DNS change  See https   github com dotnet corefx issues 11224 for more information  I suggest reading it carefully before blindly using the code suggested in the linked blog post

User · Answer

Short answer  No  the statement in the currently accepted answer is NOT accurate   The general consensus is that you do not  should not  need to dispose of HttpClient    Long answer  BOTH of the following statements are true and achieveable at the same time     HttpClient is intended to be instantiated once and re-used throughout the life of an application   quoted from official documentation  An IDisposable object is supposed recommended to be disposed    And they DO NOT NECESSARILY CONFLICT with each other  It is just a matter of how you organize your code to reuse an HttpClient AND still dispose it properly   An even longer answer quoted from my another answer   It is not a coincidence to see people in some blog posts blaming how HttpClient  s IDisposable interface makes them tend to use the using  var client   new HttpClient          pattern and then lead to exhausted socket handler problem   I believe that comes down to an unspoken  mis  conception   an IDisposable object is expected to be short-lived    HOWEVER  while it certainly looks like a short-lived thing when we write code in this style   using  var foo   new SomeDisposableObject                  the official documentation on IDisposable never mentions IDisposable objects have to be short-lived  By definition  IDisposable is merely a mechanism to allow you to release unmanaged resources  Nothing more  In that sense  you are EXPECTED to eventually trigger the disposal  but it does not require you to do so in a short-lived fashion   It is therefore your job to properly choose when to trigger the disposal  base on your real object s life cycle requirement  There is nothing stopping you from using an IDisposable in a long-lived way   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

User · Answer

In my case  I was creating an HttpClient inside a method that actually did the service call   Something like    public void DoServiceCall       var client   new HttpClient      await client PostAsync        In an Azure worker role  after repeatedly calling this method  without disposing the HttpClient   it would eventually fail with SocketException  connection attempt failed    I made the HttpClient an instance variable  disposing it at the class level  and the issue went away   So I would say  yes  dispose the HttpClient  assuming its safe  you don t have outstanding async calls  to do so

User · Answer

In typical usage  responses lt 2GB  it is not necessary to Dispose the HttpResponseMessages   The return types of the HttpClient methods should be Disposed if their Stream Content is not fully Read  Otherwise there is no way for the CLR to know those Streams can be closed until they are garbage collected    If you are reading the data into a byte    e g  GetByteArrayAsync  or string  all data is read  so there is no need to dispose  The other overloads will default to reading the Stream up to 2GB  HttpCompletionOption is ResponseContentRead  HttpClient MaxResponseContentBufferSize default is 2GB    If you set the HttpCompletionOption to ResponseHeadersRead or the response is larger than 2GB  you should clean up  This can be done by calling Dispose on the HttpResponseMessage or by calling Dispose Close on the Stream obtained from the HttpResonseMessage Content or by reading the content completely   Whether you call Dispose on the HttpClient depends on whether you want to cancel pending requests or not

[c#] Do HttpClient and HttpClientHandler have to be disposed between requests?

Examples related to c#

Examples related to .net-4.5

Examples related to idisposable

Examples related to using

Examples related to dotnet-httpclient