Failed to send any data, Sometimes TaskCanceledException catched, when httpClient.GetAsync() is called

Question

I developed C# .net 4.6.1 application (this is Windows Service Application). In the application I use HttpClient for communicate with our backend API. Over time the application not sending the request to our backend (TaskCanceledException is catched).

Here is stacktrace of this exception

System.Threading.Tasks.TaskCanceledException · A task was cancelled.

System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess(Task task)
System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification(Task task)
TestHttpClient+<GetRequestAsync>d__20.MoveNext()

This issue solves in two reason

1. after restart application
2. When attempt the same request repeatedly

I investigated this issue using Fiddler, when an exception occurs and in normal condition

1. In normal mode fiddler shows 2 requests

• Result=200, Protocol=HTTP, Host = Tunnel to, Url = api.example.com:443

in SyntaxView tab: A SSLv3-compatible ClientHello handshake was found. Fiddler extracted the parameters below.

• Result=200, Protocol=HTTPS, Host = api.example.com, Url = /test

2. In failed mode Fiddler shows only 1 requst

• Result=200, Protocol=HTTP, Host = Tunnel to, Url = api.example.com:443,

in SyntaxView tab: After the client received notice of the established CONNECT, it failed to send any data

Here is the snippet of our code.

class Program
{
  static void Main(string[] args)
  {
    // I Tried also without  Task.Run() i.e. MyClass myClass = GetAsync().Result; 
    MyClass myClass = Task.Run(() => GetAsync().Result).Result ;
  }
        
  private static async Task<MyClass> GetAsync()
  {
    // I Tried also without .ConfigureAwait(false)
     MyClassResponse myClassResponse = await TestHttpClient.GetMyClassResponse().ConfigureAwait(false);
    return MyClass.Create(myClassResponse);
  }
}

public static class TestHttpClient
{
   private static HttpClient _httpClient;
   
   public static void Init()
   {
      ServicePointManager.SecurityProtocol |= (SecurityProtocolType.Ssl3 | 
                SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | 
                                             SecurityProtocolType.Tls);
      ServicePointManager.DefaultConnectionLimit = 10;
     _httpClient = CreateHttpClient();
   }

   private static HttpClient CreateHttpClient()
   {
      HttpClient client = new HttpClient();
      client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("token .....");
      client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
      client.Timeout = TimeSpan.FromMilliseconds(10000);
      return client;
    }

   public static async Task<MyClassResponse> GetMyClassResponse()
   {
      HttpResponseMessage response = await GetRequestAsync("https://api.example.com/test");
      return await ParseToMyClassResponse<MyClassResponse>(response);
   }
 
    private static async Task<HttpResponseMessage> GetRequestAsync(string url)
   {
        try
        {
           return await _httpClient.GetAsync(new Uri(url));
         }
         catch (TaskCanceledException)
         {
          return new HttpResponseMessage(HttpStatusCode.RequestTimeout);
         }
    }

    private static async Task<T> ParseToMyClassResponse<T>(HttpResponseMessage response) where T : MyClassResponse, new()
        {
            T myClassResponse;
            try
            {
                string content = await response.Content.ReadAsStringAsync();
                response.EnsureSuccessStatusCode();
                myClassResponse = JsonConvert.DeserializeObject<T>(content);
                           }
            catch (Exception ex)
            {
                myClassResponse = new T();
            }

            response.Dispose();
            return myClassResponse;
        }
}

What am I doing wrong?

Why Fiddler shows "After the client received notice of the established CONNECT, it failed to send any data" message.

Answer 1

1. First of all, replace this

static void Main(string[] args)
{
    // I Tried also without  Task.Run() i.e. MyClass myClass = GetAsync().Result; 
    MyClass myClass = Task.Run(() => GetAsync().Result).Result ;
}

with whis

static async Task Main(string[] args)
{
    MyClass myClass = await GetAsync();
    
    Console.WriteLine("All done.");
    Console.ReadKey();
}

2. HttpResponseMessage is IDisposable, use disposing properly

public static async Task<MyClassResponse> GetMyClassResponse()
{
    using (HttpResponseMessage response = await GetRequestAsync("https://api.example.com/test"))
    {
        return await ParseToMyClassResponse<MyClassResponse>(response);
    }
}

And remove response.Dispose() from ParseToMyClassResponse

3. For additional test I've rewritten the code to make it simpler.

public class Program
{
    private readonly static HttpClient client = new HttpClient();

    static async Task Main(string[] args)
    {
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("token .....");
        client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
        client.Timeout = TimeSpan.FromMilliseconds(10000);
        ServicePointManager.DefaultConnectionLimit = 10;

        try
        {
            MyClassResponse myClassResponse = await GetAPIResponseAsync("https://api.example.com/test");
            MyClass myClass = MyClass.Create(myClassResponse);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex.Message);
            Console.WriteLine();
            Console.WriteLine(ex.StackTrace);
        }

        Console.WriteLine("All done.");
        Console.ReadKey();
    }

    private static async Task<T> GetAPIResponseAsync<T>(string url)
    {
        using (HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead))
        {
            response.EnsureSuccessStatusCode();
            string content = await response.Content.ReadAsStringAsync();
            return JsonConvert.DeserializeObject<T>(content);
        }
    }
}

Test this version.

Additionally it's not recommended to change SecurityProtocol in code because it makes the app vulnerable, use default instead. If you want to change TLS version for test, edit Windows Registry.

---

Updated

I've looked at the source.

This is a kind of bad concurrent programming. You run async function in task and block task where it being executed and block current thread at the same time.

Task<PassResponse> task = Task.Run(() => GetPass(scannedValue).Result);
PassResponse passResponse = task.Result;

You may reach the same result this way

PassResponse passResponse = GetPass(scannedValue).Result;

---

One more try

let's change this line to avoid possible deadlocks

return await _httpClient.GetAsync(new Uri(url));

to

return await _httpClient.GetAsync(new Uri(url)).ConfigureAwait(false);

And this one

string content = await response.Content.ReadAsStringAsync();

to

string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);