/// <summary>
/// Asynchronously downloads a string from the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="postdata">The post data.</param>
/// <param name="dataCompression">The post data compression method.</param>
public static async Task<DownloadResult<String>> DownloadStringAsync(Uri url, HttpMethod method = null, bool acceptEncoded = false,
string postdata = null, DataCompression dataCompression = DataCompression.None)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
throw new ArgumentException(urlValidationError);
HttpPostData postData = String.IsNullOrWhiteSpace(postdata) ? null : new HttpPostData(postdata, dataCompression);
HttpClientServiceRequest request = new HttpClientServiceRequest();
try
{
HttpResponseMessage response =
await request.SendAsync(url, method, postData, dataCompression, acceptEncoded, StringAccept).ConfigureAwait(false);
using (response)
{
Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return GetString(request.BaseUrl, stream);
}
}
catch (HttpWebClientServiceException ex)
{
return new DownloadResult<String>(String.Empty, ex);
}
}
/// <summary>
/// Asynchronously downloads a string from the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="postdata">The post data.</param>
/// <param name="dataCompression">The post data compression method.</param>
/// <param name="token">The ESI token, or null if none is used.</param>
public static async Task <DownloadResult <string> > DownloadStringAsync(Uri url,
HttpMethod method = null, bool acceptEncoded = false, string postdata = null,
DataCompression dataCompression = DataCompression.None, string token = null)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
HttpPostData postData = string.IsNullOrWhiteSpace(postdata) ? null : new HttpPostData(postdata, dataCompression);
HttpClientServiceRequest request = new HttpClientServiceRequest();
request.AuthToken = token;
request.AcceptEncoded = acceptEncoded;
request.DataCompression = dataCompression;
try
{
HttpResponseMessage response = await request.SendAsync(url, method, postData,
StringAccept).ConfigureAwait(false);
using (response)
{
Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(GetString(request.BaseUrl, stream, response));
}
}
catch (HttpWebClientServiceException ex)
{
return(new DownloadResult <string>(string.Empty, ex));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpClientServiceRequest"/> class.
/// </summary>
public HttpClientServiceRequest()
{
m_redirectsRemaining = HttpWebClientServiceState.MaxRedirects;
DataCompression = DataCompression.None;
m_acceptEncoded = false;
AuthToken = null;
// Pull the timeout from the settings
TimeSpan timeoutSetting = TimeSpan.FromSeconds(Settings.Updates.HttpTimeout);
s_timeout = timeoutSetting <TimeSpan.FromSeconds(1) || timeoutSetting> TimeSpan.FromMinutes(5)
? TimeSpan.FromSeconds(20)
: timeoutSetting;
}
/// <summary>
/// Initializes a new instance of the <see cref="HttpPostData"/> class.
/// </summary>
/// <param name="data">The data.</param>
/// <param name="dataCompression">The compression.</param>
public HttpPostData(string data, DataCompression dataCompression = DataCompression.None)
{
m_data = data;
byte[] encoded = Encoding.UTF8.GetBytes(data);
switch (dataCompression)
{
case DataCompression.Gzip:
m_content = Util.GZipCompress(encoded);
break;
case DataCompression.Deflate:
m_content = Util.DeflateCompress(encoded);
break;
case DataCompression.None:
m_content = encoded;
break;
default:
throw new NotImplementedException();
}
}
/// <summary>
/// Synchronously downloads a string from the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="postdata">The post data.</param>
/// <param name="dataCompression">The post data compression method.</param>
/// <returns></returns>
public static DownloadResult<String> DownloadString(Uri url, HttpMethod method = null, bool acceptEncoded = false,
string postdata = null, DataCompression dataCompression = DataCompression.None)
=> DownloadStringAsync(url, method, acceptEncoded, postdata, dataCompression).Result;
/// <summary>
/// Asynchronously sends a request to the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
/// <param name="postData">The post data.</param>
/// <param name="dataCompression">The data compression.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="accept">The accept.</param>
/// <returns></returns>
public async Task<HttpResponseMessage> SendAsync(Uri url, HttpMethod method, HttpPostData postData,
DataCompression dataCompression,
bool acceptEncoded, string accept)
{
while (true)
{
// Store params
m_url = url;
m_accept = accept;
m_postData = postData;
m_method = postData == null || method == null ? HttpMethod.Get : method;
m_dataCompression = postData == null ? DataCompression.None : dataCompression;
m_acceptEncoded = acceptEncoded;
HttpResponseMessage response = null;
try
{
HttpClientHandler httpClientHandler = GetHttpClientHandler();
HttpRequestMessage request = GetHttpRequest();
response = await GetHttpResponseAsync(httpClientHandler, request).ConfigureAwait(false);
EnsureSuccessStatusCode(response);
}
catch (HttpWebClientServiceException)
{
throw;
}
catch (HttpRequestException ex)
{
if (ex.InnerException is WebException)
throw HttpWebClientServiceException.HttpWebClientException(url, ex.InnerException);
if (response == null)
throw HttpWebClientServiceException.Exception(url, ex);
if (response.StatusCode != HttpStatusCode.Redirect && response.StatusCode != HttpStatusCode.MovedPermanently)
{
throw HttpWebClientServiceException.HttpWebClientException(url, ex, response.StatusCode);
}
}
catch (WebException ex)
{
// We should not get a WebException here but keep this as extra precaution
throw HttpWebClientServiceException.HttpWebClientException(url, ex);
}
catch (TaskCanceledException ex)
{
// We throw a request timeout if the task gets cancelled due to the timeout setting
throw HttpWebClientServiceException.HttpWebClientException(url, new HttpRequestException(ex.Message),
HttpStatusCode.RequestTimeout);
}
catch (Exception ex)
{
throw HttpWebClientServiceException.Exception(url, ex);
}
if (response.StatusCode != HttpStatusCode.Redirect && response.StatusCode != HttpStatusCode.MovedPermanently)
{
return response;
}
// When the address has been redirected, connects to the redirection
Uri target = response.Headers.Location;
response.Dispose();
if (m_redirectsRemaining-- <= 0)
throw HttpWebClientServiceException.RedirectsExceededException(m_url);
m_referrer = m_url;
m_url = new Uri(m_url, target);
url = m_url;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DataHead" /> class
/// </summary>
/// <param name="compression">Preferred compression</param>
public DataHead(DataCompression compression)
{
Compression = compression;
Size = DataHeadSize;
}
/// <summary>
/// Asynchronously downloads an xml file from the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="method">The method.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="postdata">The post data.</param>
/// <param name="dataCompression">The post data compression method.</param>
public static async Task <DownloadResult <IXPathNavigable> > DownloadXmlAsync(Uri url, HttpMethod method = null,
bool acceptEncoded = false, string postdata = null, DataCompression dataCompression = DataCompression.None)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
HttpPostData postData = String.IsNullOrWhiteSpace(postdata) ? null : new HttpPostData(postdata, dataCompression);
HttpClientServiceRequest request = new HttpClientServiceRequest();
try
{
HttpResponseMessage response = await request
.SendAsync(url, method, postData, dataCompression, acceptEncoded, XmlAccept)
.ConfigureAwait(false);
using (response)
{
Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(GetXmlDocument(request.BaseUrl, stream));
}
}
catch (HttpWebClientServiceException ex)
{
return(new DownloadResult <IXPathNavigable>(new XmlDocument(), ex));
}
}
