CODEWITHSUNDEEP
asp.net-web-apierror-handlingasync-awaitdotnet-httpclient
nat
nat

Reputation: 2197

dealing with an error from a typed WebAPI HttpClient call

I have a number of calls I make to a webapi client which return a Task something like this

public async Task<TResp> GetMyThingAsync(TReq req)
{
    using (HttpClient client = new HttpClient())
    {
        client.BaseAddress = new Uri(BaseURI);
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
        client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/xml"));

        await HttpRuntime.Cache.GetToken().ContinueWith((t) =>
        {
            client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("XXX", t.Result);
        });

        var httpResponseMessage = await client.PostAsXmlAsync<TReq>("This/That/", req);
        httpResponseMessage.EnsureSuccessStatusCode();
        var resp = await httpResponseMessage.Content.ReadAsAsync<TResp>();
        return resp;
    }
}

the calls to the api can of course return 500's or some other problem. EnsureSuccessStatusCode() obviously throws if something like that happens, but then its too late to do anything with any information in the response. is there a nice way of dealing with this? I understand you can add a messageHandler with the client, something like HttpClient client = HttpClientFactory(new ErrorMessageHandler()) ..

var customHandler = new ErrorMessageHandler()
        { InnerHandler = new HttpClientHandler()};
HttpClient client = new HttpClient(customHandler);

is this the way to go? what would the ErroMessageHandler look like and do to return something useful to the calling controller...?

thanks muchly

nat

Upvotes: 2

Views: 1153

Answers (1)

Yuval Itzchakov
Yuval Itzchakov

Reputation: 149538

Creating a custom handler can be an elegant solution to go about logging the exception or validating the response. I am not sure if the called controller is waiting for a meaningful response from the clients end if it encounters an exception. I think the real important part is to make sure you (the client) handle the web apis errors gracefully.

This can be done in a couple of ways:

  1. You can handle exceptions locally inside the calling method. You can use the HttpResponseMessage.IsSuccessStatusCode property which indicated if a bad response returned instead of calling httpResponseMessage.EnsureSuccessStatusCode() which throws an exception, and return a custom ErrorResponse (or do whatever you decide):

    var client = new HttpClient() // No need to dispose HttpClient

client.BaseAddress = new Uri(BaseURI);
client.DefaultRequestHeaders.Accept.Clear();

client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/xml"));

var token = await HttpRuntime.Cache.GetToken();
client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("XXX", token);

var httpResponseMessage = await client.PostAsXmlAsync<TReq>("This/That/", req);
if (!httpResponseMessage.IsSuccessStatusCode)
{
   return Task.FromResult(new ErrorResponse()) // Create some kind of error response to indicate failure
}

var resp = await httpResponseMessage.Content.ReadAsAsync<TResp>();
return resp;

  2. Create a ErrorLoggingHandler which can log exceptions (or do something else) received from the web api:

    public class ErrorLoggingHandler : DelegatingHandler
{
   private readonly StreamWriter _writer; // As a sample, log to a StreamWriter

   public ErrorLoggingHandler(Stream stream)
   {
      _writer = new StreamWriter(stream);
   }

   protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, System.Threading.CancellationToken cancellationToken)
   {
      var response = await base.SendAsync(request, cancellationToken);

      if (!response.IsSuccessStatusCode)
      {
          // This would probably be replaced with real error 
          // handling logic (return some kind of special response etc..)
          _writer.WriteLine("{0}\t{1}\t{2}", request.RequestUri,
            (int) response.StatusCode, response.Headers.Date);
      }

      return response;
   }

   protected override void Dispose(bool disposing)
   {
      if (disposing)
      {
         _writer.Dispose();
      }

      base.Dispose(disposing);
   }
}

Then, you can create your HttpClient using HttpClientFactory:

var httpclient = HttpClientFactory.Create(new ErrorLoggingHandler(new FileStream(@"Location", FileMode.OpenOrCreate)));

Upvotes: 1

Related Questions