/// <summary>
/// Execute the request (which is unguarded)
/// </summary>
/// <param name="request">The request to execute</param>
/// <param name="ct">The cancellation token to use</param>
/// <returns>The <see cref="IHttpResponseMessage"/> for the request</returns>
protected async Task <IHttpResponseMessage> ExecuteRequest(IRestRequest request, CancellationToken ct)
{
AddDefaultParameters(request);
while (true)
{
if (Authenticator != null && Authenticator.CanPreAuthenticate(this, request, Credentials))
{
await Authenticator.PreAuthenticate(this, request, Credentials);
}
// Lazy initialization of the HTTP client
if (_httpClient == null)
{
_httpClient = HttpClientFactory.CreateClient(this, request);
}
bool failed = true;
var message = HttpClientFactory.CreateRequestMessage(this, request);
try
{
var bodyData = GetContent(request);
if (bodyData != null)
{
message.Content = bodyData;
}
if (message.Content != null)
{
var content = message.Content;
foreach (var param in request.Parameters.Where(x => x.Type == ParameterType.HttpHeader && x.IsContentParameter()))
{
if (content.Headers.Contains(param.Name))
{
content.Headers.Remove(param.Name);
}
if (param.ValidateOnAdd)
{
content.Headers.Add(param.Name, param.ToRequestString());
}
else
{
content.Headers.TryAddWithoutValidation(param.Name, param.ToRequestString());
}
}
}
ModifyRequestBeforeAuthentication(_httpClient, message);
if (Authenticator != null && Authenticator.CanPreAuthenticate(_httpClient, message, Credentials))
{
await Authenticator.PreAuthenticate(_httpClient, message, Credentials);
}
var response = await _httpClient.SendAsync(message, ct);
try
{
if (!response.IsSuccessStatusCode)
{
if (Authenticator != null && Authenticator.CanHandleChallenge(_httpClient, message, Credentials, response))
{
await Authenticator.HandleChallenge(_httpClient, message, Credentials, response);
continue;
}
if (!IgnoreResponseStatusCode)
{
response.EnsureSuccessStatusCode();
}
}
failed = false;
}
finally
{
if (failed)
{
if (response != null)
{
response.Dispose();
}
else
{
message.Dispose();
}
message = null;
}
}
return(response);
}
finally
{
if (failed && message != null)
{
message.Dispose();
}
}
}
}
/// <summary>
/// Execute the request (which is unguarded)
/// </summary>
/// <param name="request">The request to execute</param>
/// <param name="ct">The cancellation token to use</param>
/// <returns>The <see cref="IHttpResponseMessage"/> for the request</returns>
protected async Task <IHttpResponseMessage> ExecuteRequest(IRestRequest request, CancellationToken ct)
{
while (true)
{
if (Authenticator != null && Authenticator.CanPreAuthenticate(this, request, Credentials))
{
await Authenticator.PreAuthenticate(this, request, Credentials);
}
var requestParameters = this.MergeParameters(request);
bool failed = true;
var httpClient = _httpClient.Value;
var message = HttpClientFactory.CreateRequestMessage(this, request, requestParameters.OtherParameters);
var bodyData = GetContent(request, requestParameters);
if (bodyData != null)
{
message.Content = bodyData;
}
ModifyRequestBeforeAuthentication(httpClient, message);
if (Authenticator != null && Authenticator.CanPreAuthenticate(httpClient, message, Credentials))
{
await Authenticator.PreAuthenticate(httpClient, message, Credentials);
}
var response = await httpClient.SendAsync(message, ct);
try
{
if (!response.IsSuccessStatusCode)
{
if (Authenticator != null && Authenticator.CanHandleChallenge(httpClient, message, Credentials, response))
{
await Authenticator.HandleChallenge(httpClient, message, Credentials, response);
continue;
}
if (!IgnoreResponseStatusCode)
{
response.EnsureSuccessStatusCode();
}
}
failed = false;
}
finally
{
if (failed)
{
if (response != null)
{
response.Dispose();
}
else
{
message.Dispose();
}
}
}
return(response);
}
}