/// <summary>
/// Downloads an Xml document from the specified url using the specified POST data
/// </summary>
/// <param name="url"></param>
/// <param name="postData"></param>
/// <returns></returns>
public XmlDocument DownloadXml(string url, HttpPostData postData)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
HttpWebServiceRequest request = GetRequest();
try
{
request.GetResponse(url, new MemoryStream(), XML_ACCEPT, postData);
XmlDocument result = new XmlDocument();
if (request.ResponseStream != null)
{
request.ResponseStream.Seek(0, SeekOrigin.Begin);
result.Load(request.ResponseStream);
}
return(result);
}
finally
{
if (request.ResponseStream != null)
{
request.ResponseStream.Close();
}
}
}
/// <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();
request.AuthToken = null;
request.AcceptEncoded = acceptEncoded;
request.DataCompression = dataCompression;
try
{
HttpResponseMessage response = await request.SendAsync(url, method, postData,
XmlAccept).ConfigureAwait(false);
using (response)
{
Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(GetXmlDocument(request.BaseUrl, stream, response));
}
}
catch (HttpWebClientServiceException ex)
{
return(new DownloadResult <IXPathNavigable>(new XmlDocument(), ex));
}
}
/// <summary>
/// Asynchronously downloads an object (streaming) from the specified url.
/// </summary>
/// <param name="url">The URL.</param>
/// <param name="acceptEncoded">if set to <c>true</c> accept encoded response.</param>
/// <param name="postData">The post data. If null, GET will be used.</param>
/// <param name="parser">The function which will parse the stream.</param>
/// <param name="token">The ESI token, or null if none is used.</param>
public static async Task <DownloadResult <T> > DownloadStreamAsync <T>(Uri url,
ParseDataDelegate <T> parser, bool acceptEncoded = false,
HttpPostData postData = null, string token = null)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
HttpClientServiceRequest request = new HttpClientServiceRequest();
request.AuthToken = token;
request.AcceptEncoded = acceptEncoded;
request.DataCompression = postData?.Compression ?? DataCompression.None;
try
{
var response = await request.SendAsync(url, (postData == null)?
HttpMethod.Get : HttpMethod.Post, postData, StreamAccept).
ConfigureAwait(false);
using (response)
{
var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
return(GetResult(url, stream, parser, response));
}
}
catch (HttpWebClientServiceException ex)
{
return(new DownloadResult <T>(default(T), 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>
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 an xml file from the specified url
/// </summary>
/// <param name="url"></param>
/// <param name="callback">A <see cref="DownloadXmlCompletedCallback"/> to be invoked when the request is completed</param>
/// <param name="userState">A state object to be returned to the callback</param>
/// <returns></returns>
public object DownloadXmlAsync(string url, HttpPostData postData, DownloadXmlCompletedCallback callback, object userState)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
XmlRequestAsyncState state = new XmlRequestAsyncState(callback, DownloadXmlAsyncCompleted, userState);
HttpWebServiceRequest request = GetRequest();
request.GetResponseAsync(url, new MemoryStream(), XML_ACCEPT, postData, state);
return request;
}
/// <summary>
/// Asynchronously downloads an xml file from the specified url
/// </summary>
/// <param name="url"></param>
/// <param name="callback">A <see cref="DownloadXmlCompletedCallback"/> to be invoked when the request is completed</param>
/// <param name="userState">A state object to be returned to the callback</param>
/// <returns></returns>
public object DownloadXmlAsync(string url, HttpPostData postData, DownloadXmlCompletedCallback callback, object userState)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
{
throw new ArgumentException(urlValidationError);
}
XmlRequestAsyncState state = new XmlRequestAsyncState(callback, DownloadXmlAsyncCompleted, userState);
HttpWebServiceRequest request = GetRequest();
request.GetResponseAsync(url, new MemoryStream(), XML_ACCEPT, postData, state);
return(request);
}
/// <summary>
/// Downloads an Xml document from the specified url using the specified POST data
/// </summary>
/// <param name="url"></param>
/// <param name="postData"></param>
/// <returns></returns>
public XmlDocument DownloadXml(string url, HttpPostData postData)
{
string urlValidationError;
if (!IsValidURL(url, out urlValidationError))
throw new ArgumentException(urlValidationError);
HttpWebServiceRequest request = GetRequest();
try
{
request.GetResponse(url, new MemoryStream(), XML_ACCEPT, postData);
XmlDocument result = new XmlDocument();
if (request.ResponseStream != null)
{
request.ResponseStream.Seek(0, SeekOrigin.Begin);
result.Load(request.ResponseStream);
}
return result;
}
finally
{
if (request.ResponseStream != null)
request.ResponseStream.Close();
}
}
/// <summary>
/// Asynchronously retrieve the response from the requested url to the specified response stream.
/// </summary>
public void GetResponseAsync(string url, Stream responseStream, string accept, HttpPostData postData, WebRequestAsyncState state)
{
m_asyncState = state;
m_asyncState.Request = this;
if (Dispatcher.IsMultiThreaded)
{
GetResponseDelegate caller = GetResponse;
caller.BeginInvoke(url, responseStream, accept, postData, GetResponseAsyncCompleted, caller);
}
else
{
GetResponseAsyncCompletedCore(() => GetResponse(url, responseStream, accept, postData));
}
}
/// <summary>
/// Retrieve the response from the reguested URL to the specified response stream
/// If postData is supplied, the request is submitted as a POST request, otherwise it is submitted as a GET request
/// The download process is broken into chunks for future implementation of asynchronous requests
/// </summary>
internal void GetResponse(string url, Stream responseStream, string accept, HttpPostData postData)
{
// Store params
m_url = url;
m_baseUrl = url;
m_accept = accept;
m_postData = postData;
m_responseStream = responseStream;
Stream webResponseStream = null;
HttpWebResponse webResponse = null;
try
{
webResponse = GetHttpResponse();
webResponseStream = webResponse.GetResponseStream();
int bytesRead;
long totalBytesRead = 0;
long rawBufferSize = webResponse.ContentLength / 100;
int bufferSize = (int)(rawBufferSize > m_webServiceState.MaxBufferSize ? m_webServiceState.MaxBufferSize : (rawBufferSize < m_webServiceState.MinBufferSize ? m_webServiceState.MinBufferSize : rawBufferSize));
do
{
byte[] buffer = new byte[bufferSize];
bytesRead = webResponseStream.Read(buffer, 0, bufferSize);
if (bytesRead > 0)
{
m_responseStream.Write(buffer, 0, bytesRead);
if (m_asyncState != null && m_asyncState.ProgressCallback != null)
{
totalBytesRead += bytesRead;
int progressPercentage = webResponse.ContentLength == 0 ? 0 : (int)((totalBytesRead * 100)/webResponse.ContentLength);
m_asyncState.ProgressCallback(new DownloadProgressChangedArgs(webResponse.ContentLength, totalBytesRead, progressPercentage));
}
}
} while (bytesRead > 0 && !Cancelled);
}
catch (HttpWebServiceException)
{
throw;
}
catch (WebException ex)
{
// Aborted, time out or error while processing the request
throw HttpWebServiceException.WebException(BaseUrl, m_webServiceState, ex);
}
catch (Exception ex)
{
throw HttpWebServiceException.Exception(url, ex);
}
finally
{
if (webResponseStream != null)
webResponseStream.Close();
if (webResponse != null)
webResponse.Close();
}
}
/// <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>
/// 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>
/// Asynchronously retrieve the response from the requested url to the specified response stream.
/// </summary>
public void GetResponseAsync(string url, Stream responseStream, string accept, HttpPostData postData, WebRequestAsyncState state)
{
m_asyncState = state;
m_asyncState.Request = this;
if (Dispatcher.IsMultiThreaded)
{
GetResponseDelegate caller = GetResponse;
caller.BeginInvoke(url, responseStream, accept, postData, GetResponseAsyncCompleted, caller);
}
else
{
GetResponseAsyncCompletedCore(() => GetResponse(url, responseStream, accept, postData));
}
}
/// <summary>
/// Retrieve the response from the reguested URL to the specified response stream
/// If postData is supplied, the request is submitted as a POST request, otherwise it is submitted as a GET request
/// The download process is broken into chunks for future implementation of asynchronous requests
/// </summary>
internal void GetResponse(string url, Stream responseStream, string accept, HttpPostData postData)
{
// Store params
m_url = url;
m_baseUrl = url;
m_accept = accept;
m_postData = postData;
m_responseStream = responseStream;
Stream webResponseStream = null;
HttpWebResponse webResponse = null;
try
{
webResponse = GetHttpResponse();
webResponseStream = webResponse.GetResponseStream();
int bytesRead;
long totalBytesRead = 0;
long rawBufferSize = webResponse.ContentLength / 100;
int bufferSize = (int)(rawBufferSize > m_webServiceState.MaxBufferSize ? m_webServiceState.MaxBufferSize : (rawBufferSize < m_webServiceState.MinBufferSize ? m_webServiceState.MinBufferSize : rawBufferSize));
do
{
byte[] buffer = new byte[bufferSize];
bytesRead = webResponseStream.Read(buffer, 0, bufferSize);
if (bytesRead > 0)
{
m_responseStream.Write(buffer, 0, bytesRead);
if (m_asyncState != null && m_asyncState.ProgressCallback != null)
{
totalBytesRead += bytesRead;
int progressPercentage = webResponse.ContentLength == 0 ? 0 : (int)((totalBytesRead * 100) / webResponse.ContentLength);
m_asyncState.ProgressCallback(new DownloadProgressChangedArgs(webResponse.ContentLength, totalBytesRead, progressPercentage));
}
}
} while (bytesRead > 0 && !Cancelled);
}
catch (HttpWebServiceException)
{
throw;
}
catch (WebException ex)
{
// Aborted, time out or error while processing the request
throw HttpWebServiceException.WebException(BaseUrl, m_webServiceState, ex);
}
catch (Exception ex)
{
throw HttpWebServiceException.Exception(url, ex);
}
finally
{
if (webResponseStream != null)
{
webResponseStream.Close();
}
if (webResponse != null)
{
webResponse.Close();
}
}
}
