public async Task <HttpResponseMessage> MakeRequest(HttpClientMethod method, string apiEndpoint, object requestObject = null)
{
var jsonString = requestObject == null ? null : Newtonsoft.Json.JsonConvert.SerializeObject(requestObject);
var jsonContent = new StringContent(jsonString ?? "", System.Text.Encoding.UTF8, "application/json");
Func <HttpClient, Task <HttpResponseMessage> > requestTask = null;
switch (method)
{
case HttpClientMethod.Get:
requestTask = client => client.GetAsync(apiEndpoint);
break;
case HttpClientMethod.Post:
requestTask = client => client.PostAsync(apiEndpoint, jsonContent);
break;
case HttpClientMethod.Put:
requestTask = client => client.PutAsync(apiEndpoint, jsonContent);
break;
case HttpClientMethod.Delete:
requestTask = client => client.DeleteAsync(apiEndpoint);
break;
}
return(await requestTask(HttpClient).ConfigureAwait(false));
}
/// <summary>
/// Internally make and translate the request to the Transport
/// </summary>
/// <typeparam name="TResponse"> Response Type</typeparam>
/// <param name="method">HTTP Method</param>
/// <param name="apiUrl"></param>
/// <param name="requestObj"></param>
/// <returns></returns>
internal async Task <CommunicationResult <TResponse> > InternalRequest <TResponse>(HttpClientMethod method, string apiUrl, object requestObj)
{
var returnResult = new CommunicationResult <TResponse>
{
DateSent = DateTime.Now
};
try
{
var response = await HttpClientTransport.MakeRequest(method, apiUrl, requestObj).ConfigureAwait(false);
string responseContentString = null;
if (response.Content.Headers.ContentLength > 0)
{
responseContentString = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Read this regardless of response
}
if (response.IsSuccessStatusCode)
{
returnResult.Status = CommunicationStatus.Success;
// Don't wrap this, if it throws it will (rightfully) fall to ClientError
if (typeof(TResponse) == typeof(string))
{
returnResult.Data = (TResponse)Convert.ChangeType(responseContentString, typeof(TResponse));
}
else
{
var deserialized = Newtonsoft.Json.JsonConvert.DeserializeObject <TResponse>(responseContentString);
returnResult.Data = deserialized;
}
}
else
{
returnResult.Status = CommunicationStatus.RemoteError;
returnResult.Exception = GetRemoteException(response.StatusCode, response.ReasonPhrase, response.Headers, responseContentString);
}
}
// Catch timeouts specifically
catch (TaskCanceledException ex)
{
if (ex.CancellationToken.IsCancellationRequested)
{
// Cancelled by implementation
returnResult.Status = CommunicationStatus.ClientError;
returnResult.Exception = ex;
}
else
{
// HTTP Transport Timeout
returnResult.Status = CommunicationStatus.Timeout;
}
}
catch (Exception ex)
{
returnResult.Status = CommunicationStatus.ClientError;
returnResult.Exception = ex;
}
finally
{
returnResult.DateReturned = DateTime.Now;
}
return(returnResult);
}
