/// <summary>Send an HTTP request as an asynchronous operation.</summary>
/// <returns>Returns <see cref="T:System.Threading.Tasks.Task`1" />.The task object representing the asynchronous operation.</returns>
/// <param name="request">The HTTP request message to send.</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="request" /> was null.</exception>
public virtual Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
throw new ArgumentNullException("request");
CheckDisposed();
Task<HttpResponseMessage> retObject = _handler.SendAsync(request, cancellationToken);
return retObject;
}
private void SetTaskFaulted(HttpRequestMessage request, CancellationTokenSource cancellationTokenSource, TaskCompletionSource<HttpResponseMessage> tcs, Exception e)
{
LogSendError(request, cancellationTokenSource, "SendAsync", e);
tcs.TrySetException(e);
DisposeCancellationToken(cancellationTokenSource);
}
private void StartContentBuffering(HttpRequestMessage request, CancellationTokenSource cancellationTokenSource, TaskCompletionSource<HttpResponseMessage> tcs, HttpResponseMessage response)
{
response.Content.LoadIntoBufferAsync(TransportConfiguration.MaxResponseContentBufferSize).ContinueWithStandard(delegate (Task contentTask) {
try
{
bool flag = cancellationTokenSource.Token.IsCancellationRequested;
if (contentTask.IsFaulted)
{
response.Dispose();
if (flag && (contentTask.Exception.GetBaseException() is HttpRequestException))
{
SetTaskCanceled(request, cancellationTokenSource, tcs);
}
else
{
SetTaskFaulted(request, cancellationTokenSource, tcs, contentTask.Exception.GetBaseException());
}
}
else if (contentTask.IsCanceled)
{
response.Dispose();
SetTaskCanceled(request, cancellationTokenSource, tcs);
}
else
{
SetTaskCompleted(request, cancellationTokenSource, tcs, response);
}
}
catch (Exception exception)
{
response.Dispose();
tcs.TrySetException(exception);
if (Logging.On)
{
Logging.Exception(Logging.Http, this, "SendAsync", exception);
}
}
});
}
private void SetTaskCanceled(HttpRequestMessage request, CancellationTokenSource cancellationTokenSource, TaskCompletionSource<HttpResponseMessage> tcs)
{
this.LogSendError(request, cancellationTokenSource, "SendAsync", null);
tcs.TrySetCanceled();
DisposeCancellationToken(cancellationTokenSource);
}
private void SetTaskCompleted(HttpRequestMessage request, CancellationTokenSource cancellationTokenSource, TaskCompletionSource<HttpResponseMessage> tcs, HttpResponseMessage response)
{
//if (Logging.On)
//{
// Logging.PrintInfo(Logging.Http, this, string.Format(CultureInfo.InvariantCulture, SR.net_http_client_send_completed, new object[] { Logging.GetObjectLogHash(request), Logging.GetObjectLogHash(response), response }));
//}
tcs.TrySetResult(response);
DisposeCancellationToken(cancellationTokenSource);
}
private void PrepareRequestMessage(HttpRequestMessage request)
{
Uri baseAddress = null;
if ((request.RequestUri == null) && (_baseAddress == null))
{
throw new InvalidOperationException(SR.net_http_client_invalid_requesturi);
}
if (request.RequestUri == null)
{
baseAddress = _baseAddress;
}
else if (!request.RequestUri.IsAbsoluteUri)
{
if (_baseAddress == null)
{
throw new InvalidOperationException(SR.net_http_client_invalid_requesturi);
}
baseAddress = new Uri(_baseAddress, request.RequestUri);
}
if (baseAddress != null)
{
request.RequestUri = baseAddress;
}
if (DefaultRequestHeaders != null)
{
request.Headers.AddHeaders(DefaultRequestHeaders);
}
}
private void LogSendError(HttpRequestMessage request, CancellationTokenSource cancellationTokenSource, string method, Exception e)
{
if (cancellationTokenSource.IsCancellationRequested)
{
if (Logging.On)
{
Logging.PrintError(Logging.Http, this, method, string.Format(CultureInfo.InvariantCulture, SR.net_http_client_send_canceled, new object[] { Logging.GetObjectLogHash(request) }));
}
}
else if (Logging.On)
{
Logging.PrintError(Logging.Http, this, method, string.Format(CultureInfo.InvariantCulture, SR.net_http_client_send_error, new object[] { Logging.GetObjectLogHash(request), e }));
}
}
private static void DisposeRequestContent(HttpRequestMessage request)
{
HttpContent content = request.Content;
if (content != null)
{
content.Dispose();
}
}
private static void CheckRequestMessage(HttpRequestMessage request)
{
if (!request.IsSent())
{
throw new InvalidOperationException(SR.net_http_client_request_already_sent);
}
}
/// <summary>Send an HTTP request as an asynchronous operation.</summary>
/// <returns>Returns <see cref="T:System.Threading.Tasks.Task`1" />.The task object representing the asynchronous operation.</returns>
/// <param name="request">The HTTP request message to send.</param>
/// <param name="completionOption">When the operation should complete (as soon as a response is available or after reading the whole response content).</param>
/// <param name="cancellationToken">The cancellation token to cancel operation.</param>
/// <exception cref="T:System.ArgumentNullException">The <paramref name="request" /> was null.</exception>
/// <exception cref="T:System.InvalidOperationException">The request message was already sent by the <see cref="T:NMasters.Silverlight.Net.Http.HttpClient" /> instance.</exception>
public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, HttpCompletionOption completionOption, CancellationToken cancellationToken)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
this.CheckDisposed();
CheckRequestMessage(request);
this.SetOperationStarted();
this.PrepareRequestMessage(request);
CancellationTokenSource linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, this._pendingRequestsCts.Token);
// Handle timeout (create timer or something else)
//TimerThread.Timer timeoutTimer = this.SetTimeout(linkedCts);
var tcs = new TaskCompletionSource<HttpResponseMessage>();
try
{
Action<Task<HttpResponseMessage>> continuation = delegate (Task<HttpResponseMessage> task) {
try
{
DisposeRequestContent(request);
if (task.IsFaulted)
{
this.SetTaskFaulted(request, linkedCts, tcs, task.Exception.GetBaseException());
}
else if (task.IsCanceled)
{
this.SetTaskCanceled(request, linkedCts, tcs);
}
else
{
HttpResponseMessage response = task.Result;
if (response == null)
{
this.SetTaskFaulted(request, linkedCts, tcs, new InvalidOperationException(SR.net_http_handler_noresponse));
}
else if ((response.Content == null) || (completionOption == HttpCompletionOption.ResponseHeadersRead))
{
this.SetTaskCompleted(request, linkedCts, tcs, response);
}
else
{
this.StartContentBuffering(request, linkedCts, tcs, response);
}
}
}
catch (Exception exception)
{
if (Logging.On)
{
Logging.Exception(Logging.Http, this, "SendAsync", exception);
}
tcs.TrySetException(exception);
}
};
base.SendAsync(request, linkedCts.Token).ContinueWithStandard<HttpResponseMessage>(continuation);
}
catch
{
throw;
}
return tcs.Task;
}
