title: Asp.net Core HttpClient has many TIME_WAIT or CLOSE_WAIT connections
body: <p>I use <code>AddHttpClient()</code> <strong>dependency injection</strong> to add a named client to a transient service. At times, when I execute <code>netstat -a</code> on the server,  I see many connections open with <code>TIME_WAIT</code> or <code>CLOSE_WAIT</code> status. I believe that these connections take up so much resource that, other <code>TCP</code> connections are unable to operate. Is this possible? Is there a way to stop these, and is it safe?</p>
  
  <pre><code>public class Startup
  {
      public Startup(IConfiguration configuration)
      {
          Configuration = configuration;
      }
  
      public IConfiguration Configuration { get; }
  
      // This method gets called by the runtime. Use this method to add services to the container.
      public void ConfigureServices(IServiceCollection services)
      {
          ServicePointManager.DefaultConnectionLimit = 200;
  
          services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
  
          services.AddHttpClient(FirebaseService.FirebaseServiceClient, ConfigureFirebaseClient);
  
          services.AddTransient&lt;FirebaseService&gt;();
      }
  
      // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
      public void Configure(IApplicationBuilder app, IHostingEnvironment env)
      {
          if (env.IsDevelopment())
          {
              app.UseDeveloperExceptionPage();
          }
          else
          {
              // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
              app.UseHsts();
          }
  
          app.UseHttpsRedirection();
          app.UseMvc();
      }
  
      void ConfigureFirebaseClient(HttpClient client)
      {
          var scopes = new string[] { "https://www.googleapis.com/auth/firebase.messaging" };
  
          Stream certificateStream = File.OpenRead("firebase-adminsdk.json");
  
          var serviceCredentials = GoogleCredential.FromStream(certificateStream);
          certificateStream.Close();
  
          var scopedCredentials = serviceCredentials.CreateScoped(scopes);
          var token = scopedCredentials.UnderlyingCredential.GetAccessTokenForRequestAsync().GetAwaiter().GetResult();
          client.SetBearerToken(token);
      }
  }
  
  public class FirebaseService
  {
      public static string FirebaseServiceClient = "FirebaseServiceClient";
  
      private HttpClient _client;
  
      private readonly ILogger&lt;FirebaseService&gt; _logger;
      private readonly string _messagingUrl; 
  
      public FirebaseService(
          ILogger&lt;FirebaseService&gt; logger,
          IHttpClientFactory clientFactory)
      {
          _logger = logger;
          _messagingUrl = "https://fcm.googleapis.com/v1/projects/test2/messages:send";
          _client = clientFactory.CreateClient(FirebaseServiceClient);
      }
  
      public async Task&lt;string&gt; PostToFirebase(Dictionary&lt;string, string&gt; payload)
      {
          HttpResponseMessage result = null;
          string cont = null;
          try
          {
              var content = JsonConvert.SerializeObject(payload, Formatting.None);
              var stringContent = new StringContent(content, Encoding.UTF8, "application/json");
  
              result = await _client.PostAsync(_messagingUrl, stringContent);
              cont = await result.Content.ReadAsStringAsync();
              return cont;
          }
          finally
          {
              result?.Dispose();
          }
      }
  
  }
  
  public class ValuesController : ControllerBase
  {
      private readonly IServiceProvider _serviceProvider;
  
      public ValuesController(IServiceProvider serviceProvider)
      {
          _serviceProvider = serviceProvider;
      }
  
      [HttpGet]
      public async Task&lt;IActionResult&gt; Get()
      {
          var payload = new Dictionary&lt;string, string&gt;();
          List&lt;Task&gt; tasks = new List&lt;Task&gt;();
          for (int i = 0; i &lt; 100; i++)
          {
              FirebaseService firebaseService = (FirebaseService)_serviceProvider.GetService(typeof(FirebaseService));
              var task = firebaseService.PostToFirebase(payload);
              tasks.Add(task);
              Console.WriteLine(i);
          }
  
          await Task.WhenAll(tasks.ToArray());
  
          //Console.WriteLine(result);
  
          return Ok();
      }
  
  }
  </code></pre>