title: Getting SocketException when sending httpclient request
body: <p>I have a Base class for Webservice request, my code is working before in my Xamarin Android Application but now I got an error. I already .Dispose() the httpclient after getting the response and also .Disponse() the HttpResponseMessage Variable inside my request function.</p>
  
  <p><strong>NOTE: "<a href="https://book.sogohotel.com" rel="nofollow noreferrer">https://book.sogohotel.com</a>" is only a dummy domain because I don't want to expose the real IP or Site</strong></p>
  
  <p>I have 2 Async Method.</p>
  
  <pre><code>public async Task GetAvailableRooms(){
   await GetToken();
   await GetRooms(Token);
  }
  </code></pre>
  
  <p>After getting the token then hitting the GetRoom() I got the Socket Exception</p>
  
  <p>I try to sent requests using POSTMAN but I get the response without ERROR.</p>
  
  <pre><code>System.Net.Sockets.SocketException(0x80004005): No such host is known
  at System.Net.Http.ConnectHelper.ConnectAsync(System.String host, System.Int32 port, System.Threading.CancellationToken cancellationToken)[0x000c8] in /Users/builder/jenkins/workspace/archive-mono/2019-08/android/release/external/corefx/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/ConnectHelper.cs:65 }
  </code></pre>
  
  <p>Does anyone encounter this before especially Xamarin Mobile Developer?</p>
  
  <p>Heres my Base class code:</p>
  
  <pre><code>using MyApp.Mobile.Client.APIService.Helper;
  using MyApp.Mobile.Client.Common.Constants;
  using Newtonsoft.Json;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Net;
  using System.Net.Http;
  using System.Net.Http.Headers;
  using System.Text;
  using System.Threading.Tasks;
  
  namespace MyApp.Mobile.Client.APIService.Base
  {
      public class ApiServiceBase
      {
          public static string AppBaseAddress = @"https://book.sogohotel.com";
  
          private Uri BaseAddress = new Uri(AppBaseAddress);
          public static string AccessToken { get; set; }
          public HttpClient httpClient { get; set; }
  
          public ApiServiceBase()
          {
              this.httpClient = new HttpClient() { BaseAddress = BaseAddress };
              this.httpClient.Timeout = TimeSpan.FromSeconds(60);
              this.httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
          }
  
          /// &lt;summary&gt;
          /// GetRequestAsync method handles the Get Request sent to API and returns a type HttpContent.
          /// &lt;/summary&gt;
          /// &lt;param name="requestUri"&gt;&lt;/param&gt;
          /// &lt;returns&gt;HttpContent&lt;/returns&gt;
          public async Task&lt;HttpContent&gt; GetRequestAsync(string requestUri)
          {
              HttpResponseMessage requestResponse = new HttpResponseMessage();
  
              try
              {
                  if (!string.IsNullOrEmpty(AccessToken))
                  {
                      this.httpClient.DefaultRequestHeaders.Add("x-session-token", AccessToken);
                  }
  
                  requestResponse = await this.httpClient.GetAsync(requestUri);
  
                  if (requestResponse.IsSuccessStatusCode)
                  {
                      //Dev Hint: This clause statement represents that the Get action has been processed successfully.
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.InternalServerError)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered InternalServer Error.
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.Unauthorized)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered Unauthorized Error.
                  }
  
              }
              catch (TaskCanceledException)
              {
                  //Dev Hint: Need to throw or log the encountered TaskCanceledException.
              }
              catch (HttpRequestException e)
              {
                  throw e.InnerException;
                  //Dev Hint: Need to throw or log the encountered HttpRequestException.
              }
              catch (Exception)
              {
                  //Dev Hint: Need to throw or log the encountered General Exception.
              }
              var content = requestResponse?.Content;
              requestResponse.Dispose();
              httpClient.Dispose();
              return content;
          }
  
          public async Task&lt;T&gt; GetRequestWithResponseAsync&lt;T&gt;(string requestUri)
          {
              try
              {
                  var response = await GetRequestAsync(requestUri);
                  var responseContent = response.ReadAsStringAsync().Result;
  
                  if (response == null)
                      return default(T);
  
                  var responseResult =  JsonConvert.DeserializeObject&lt;T&gt;(responseContent);
  
                  return responseResult;
              }
              catch (Exception e)
              {
                  //Dev Hint: Need to throw or log the encountered General Exception.
                  throw e;
              }
          }
  
          public async Task&lt;IEnumerable&lt;T&gt;&gt; GetRequestWithResponseListAsync&lt;T&gt;(string requestUri)
          {
              try
              {
                  var response = await GetRequestAsync(requestUri);
                  var responseContent = response.ReadAsStringAsync().Result;
  
                  if (response == null)
                      return default(IEnumerable&lt;T&gt;);
  
                  var responseResult = JsonConvert.DeserializeObject&lt;IEnumerable&lt;T&gt;&gt;(responseContent);
  
                  return responseResult;
              }
              catch(JsonException je)
              {
  
                  // JsonConvert.DeserializeObject error
                  // Dev Hint: Need to throw or log the encountered General Exception.
                  throw je;
              }
              catch (Exception e)
              {
                  //Dev Hint: Need to throw or log the encountered General Exception.
                  throw e;
              }
          }
  
  
          /// &lt;summary&gt;
          /// PostRequestAsync method handles the Post Request sent to API and returns a type HttpContent.
          /// &lt;/summary&gt;
          /// &lt;typeparam name="T"&gt;&lt;/typeparam&gt;
          /// &lt;param name="requestUri"&gt;&lt;/param&gt;
          /// &lt;param name="content"&gt;&lt;/param&gt;
          /// &lt;returns&gt;HttpContent&lt;/returns&gt;
          public async Task&lt;HttpContent&gt; PostRequestAsync&lt;T&gt;(string requestUri, T content)
          {
              string jsonString = string.Empty;
              StringContent stringJsonContent = default(StringContent);
              HttpResponseMessage requestResponse = new HttpResponseMessage();
  
              try
              {
                  if (!string.IsNullOrEmpty(AccessToken))
                  {
                      this.httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", AccessToken);
                  }
  
                  jsonString = JsonConvert.SerializeObject(content);
                  stringJsonContent = new StringContent(jsonString, Encoding.UTF8, "application/json");
                  requestResponse = await this.httpClient.PostAsync(requestUri, stringJsonContent);
  
                  if (requestResponse.IsSuccessStatusCode)
                  {
                      //Dev Hint: This clause statement represents that the Get action has been processed successfully.
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.InternalServerError)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered InternalServer Error.
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.Unauthorized)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered Unauthorized Error.
                  }
  
              }
              catch (TaskCanceledException)
              {
                  //Dev Hint: Need to throw or log the encountered TaskCanceledException.
              }
              catch (HttpRequestException)
              {
                  //Dev Hint: Need to throw or log the encountered HttpRequestException.
              }
              catch (Exception)
              {
                  //Dev Hint: Need to throw or log the encountered General Exception.
              }
  
              var responseContent = requestResponse?.Content;
              requestResponse.Dispose();
              httpClient.Dispose();
              return responseContent;
          }
  
          public async Task&lt;string&gt; GetSessionTokenAsync()
          {
              HttpResponseMessage requestResponse = new HttpResponseMessage();
              try
              {
  
                  requestResponse = await this.httpClient.PostAsync(EndPoints.GetSessionToken, null);
                  if (requestResponse.IsSuccessStatusCode)
                  {
                      //Dev Hint: This clause statement represents that the Get action has been processed successfully.
                      var result = requestResponse.Headers.GetValues("x-session-token");
                      return result.FirstOrDefault();
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.InternalServerError)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered InternalServer Error.
                  }
                  else if (requestResponse.StatusCode == HttpStatusCode.Unauthorized)
                  {
                      //Dev Hint: This clause statement represents that the Get action has encountered Unauthorized Error.
                  }
  
              }
              catch (TaskCanceledException a)
              {
                  //Dev Hint: Need to throw or log the encountered TaskCanceledException.
              }
              catch (HttpRequestException b)
              {
                  //Dev Hint: Need to throw or log the encountered HttpRequestException.
              }
              catch (Exception c)
              {
                  //Dev Hint: Need to throw or log the encountered General Exception.
              }
  
              return requestResponse.StatusCode.ToString();
          }
      }
  }
  </code></pre>