/// <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; }