/// <summary>
/// Create an <see cref="HttpWebRequest" /> from the given <see cref="IHttpRequest" /> instance
/// </summary>
/// <param name="request">The instance of <see cref="IHttpRequest" /></param>
/// <param name="progress">The progress reporter</param>
/// <returns>An instance of <see cref="HttpWebRequest" /></returns>
protected virtual HttpWebRequest CreateRequest(IHttpRequest request, Interfaces.Infrastructure.IProgress <double> progress)
{
var uri = request.GetUri();
HttpWebRequest realRequest;
if (uri.Scheme == Uri.UriSchemeHttps)
{
realRequest = (HttpWebRequest)WebRequest.Create(uri);
realRequest.ProtocolVersion = HttpVersion.Version11;
}
else
{
realRequest = (HttpWebRequest)WebRequest.Create(request.GetUri());
}
realRequest.Method = request.GetMethod();
var headers = request.GetHeaders();
headers.Keys.ToList().ForEach(key =>
{
var handler = HeaderHandlers.FirstOrDefault(h => h.CanSetHeader(realRequest, key));
if (null != handler)
{
handler.SetHeader(realRequest, key, headers[key]);
}
else
{
realRequest.Headers.Add(key, headers[key]);
}
});
return(SetBody(realRequest, request.GetBody(), progress));
}
/// <summary>
/// Send an http request using the prebuilt <see cref="IRequestBuilder{T}" /> to build a request from the
/// <typeparamref name="TParameter" />
/// </summary>
/// <typeparam name="TResult">The type of the result</typeparam>
/// <typeparam name="TParameter">The type of the parameter</typeparam>
/// <param name="parameter">The parameter instance</param>
/// <param name="progress">The progress reporter</param>
/// <returns>The data returned from the server</returns>
protected async Task <TResult> FetchAsync <TResult, TParameter>(TParameter parameter,
Interfaces.Infrastructure.IProgress <double> progress = null)
where TParameter : HttpParameter
{
return(await TaskBuilder.Run(async() =>
{
try
{
return ResponseResolver.Resolve <TResult>(Client.GetResponse(await CreateHttpRequest(parameter), progress));
}
catch (Exception e)
{
Error(e);
return default(TResult);
}
}).ConfigureAwait(false));
}
private static HttpWebRequest SetBody(HttpWebRequest request, Stream body, Interfaces.Infrastructure.IProgress <double> progress)
{
if (body != null && body.Length > 0)
{
//Ensure that we have ContentLength set in the headers
if (request.ContentLength == 0)
{
request.ContentLength = body.Length;
}
//Upload and handle progress
var requestStream = request.GetRequestStream();
var total = body.Length;
body.Seek(0, SeekOrigin.Begin);
body.CopyTo(requestStream, 4096, bytes => progress?.Report(bytes * 1.0 / total));
body.Close();
requestStream.Close();
}
return(request);
}
public IHttpResponse GetResponse(IHttpRequest request, Interfaces.Infrastructure.IProgress <double> progress)
{
try
{
var realRequest = CreateRequest(request, progress);
#if DEBUG
var time1 = DateTime.Now;
#endif
var response = GenerateResponse(realRequest.GetResponse() as HttpWebResponse);
#if DEBUG
var time2 = DateTime.Now;
Debug(
$"[{(time2 - time1).TotalMilliseconds} ms]-[{request.GetMethod()}] {request.GetUri()} {Environment.NewLine} {response.GetResponseStream().AsString()}");
#endif
return(response);
}
catch (WebException e)
{
Error(e.Response.GetResponseStream().AsString());
throw;
}
}
public IHttpResponse GetResponse(IHttpRequest request, Interfaces.Infrastructure.IProgress <double> progress = null)
{
#if DEBUG
var time1 = DateTime.Now;
#endif
var requestMessage = new HttpRequestMessage(HttpMethod.Get, request.GetUri())
{
Content = new StreamContent(request.GetBody())
};
requestMessage.Headers.Clear();
requestMessage.Content.Headers.Clear();
request.GetHeaders().Where(header => !header.Key.StartsWith("Content")).ToList()
.ForEach(header => requestMessage.Headers.Add(header.Key, header.Value));
request.GetHeaders().Where(header => header.Key.StartsWith("Content")).ToList()
.ForEach(header => requestMessage.Content.Headers.Add(header.Key, header.Value));
var responseMessage = Client.SendAsync(requestMessage).Result;
var response = new GetWithPayloadHttpResponse(responseMessage);
#if DEBUG
var time2 = DateTime.Now;
Debug(
$"[{(time2 - time1).TotalMilliseconds} ms]-[{request.GetMethod()}] {request.GetUri()} {Environment.NewLine} {response.GetResponseStream().AsString()}");
#endif
return(response);
}
public IHttpResponse GetResponse(IHttpRequest request, Interfaces.Infrastructure.IProgress <double> progress)
{
return(AvailableClients.Value.FirstOrDefault(client => client.CanGetResponse(request))?.GetResponse(request, progress));
}
/// <summary>
/// Send an http request using the prebuilt <see cref="IRequestBuilder{T}" /> to build a request from the
/// <typeparamref name="TParameter" />
/// </summary>
/// <typeparam name="TParameter"></typeparam>
/// <param name="parameter"></param>
/// <param name="progress"></param>
/// <returns></returns>
protected async Task SendAsync <TParameter>(TParameter parameter, Interfaces.Infrastructure.IProgress <double> progress = null)
where TParameter : HttpParameter
{
await TaskBuilder.Run(async() => Client.GetResponse(await CreateHttpRequest(parameter), progress)).ConfigureAwait(false);
}
/// <summary>
/// Send an http request without caring about the response
/// </summary>
/// <param name="request">The http request</param>
/// <param name="progress">The progress reporter</param>
/// <returns>The task used to wait</returns>
protected async Task SendAsync(HttpRequest request, Interfaces.Infrastructure.IProgress <double> progress = null)
{
await TaskBuilder.Run(() => Client.GetResponse(request, progress)).ConfigureAwait(false);
}
/// <summary>
/// Send an http request and wait to fetch some data from the response
/// </summary>
/// <typeparam name="T">The type of the data</typeparam>
/// <param name="request">The http request</param>
/// <param name="progress">The progress handler</param>
/// <returns>The data returned from the server</returns>
protected async Task <T> FetchAsync <T>(HttpRequest request, Interfaces.Infrastructure.IProgress <double> progress = null)
{
return(await TaskBuilder.Run(() => ResponseResolver.Resolve <T>(Client.GetResponse(request, progress))).ConfigureAwait(false));
}
