private void SendRequest(string requestUri, object request, Action <WebRequest> callback) { var isHttpGet = HttpMethod != null && HttpMethod.ToUpper() == "GET"; if (isHttpGet) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } SendRequest(HttpMethod ?? DefaultHttpMethod, requestUri, request, callback); }
private void SendWebRequest <TResponse>(string httpMethod, string absoluteUrl, object request, CancellationToken token, Action <TResponse> onSuccess, Action <object, Exception> onError, Action <WebResponse> onResponseInit = null) { if (httpMethod == null) { throw new ArgumentNullException(nameof(httpMethod)); } this.PopulateRequestMetadata(request); var requestUri = absoluteUrl; var hasQueryString = request != null && !httpMethod.HasRequestBody(); if (hasQueryString) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } var webRequest = this.CreateHttpWebRequest(requestUri); var requestState = new AsyncState <TResponse>(BufferSize) { HttpMethod = httpMethod, Url = requestUri, WebRequest = webRequest, Request = request, Token = token, OnResponseInit = onResponseInit, OnSuccess = onSuccess, OnError = onError, UseSynchronizationContext = CaptureSynchronizationContext ? SynchronizationContext.Current : null, HandleCallbackOnUIThread = HandleCallbackOnUiThread, }; if (!DisableTimer) { requestState.StartTimer(this.Timeout.GetValueOrDefault(DefaultTimeout)); } SendWebRequestAsync(httpMethod, request, requestState, webRequest); }
public virtual Task <TResponse> PostFilesWithRequestAsync <TResponse>(string requestUri, object request, UploadFile[] files) { var queryString = QueryStringSerializer.SerializeToString(request); var nameValueCollection = PclExportClient.Instance.ParseQueryString(queryString); var content = new MultipartFormDataContent(); foreach (string key in nameValueCollection) { var value = nameValueCollection[key]; content.Add(new StringContent(value), $"\"{key}\""); } var disposables = new List <IDisposable> { content }; for (int i = 0; i < files.Length; i++) { var file = files[i]; var fileBytes = file.Stream.ReadFully(); var fileContent = new ByteArrayContent(fileBytes, 0, fileBytes.Length); disposables.Add(fileContent); var fieldName = file.FieldName ?? $"upload{i}"; var fileName = file.FileName ?? $"upload{i}"; fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = fieldName, FileName = fileName, }; fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse(MimeTypes.GetMimeType(fileName)); content.Add(fileContent, fileName, fileName); } return(SendAsync <TResponse>(HttpMethods.Post, requestUri, content) .ContinueWith(t => { foreach (var d in disposables) { d.Dispose(); } return t.Result; }, TaskContinuationOptions.ExecuteSynchronously)); }
private void SendWebRequest <TResponse>(string httpMethod, string absoluteUrl, object request, Action <TResponse> onSuccess, Action <TResponse, Exception> onError) { if (httpMethod == null) { throw new ArgumentNullException("httpMethod"); } var requestUri = absoluteUrl; var httpGetOrDeleteOrHead = (httpMethod == "GET" || httpMethod == "DELETE" || httpMethod == "HEAD"); var hasQueryString = request != null && httpGetOrDeleteOrHead; if (hasQueryString) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } var webRequest = this.CreateHttpWebRequest(requestUri); var requestState = new AsyncState <TResponse>(BufferSize) { HttpMethod = httpMethod, Url = requestUri, WebRequest = webRequest, Request = request, OnSuccess = onSuccess, OnError = onError, UseSynchronizationContext = CaptureSynchronizationContext ? SynchronizationContext.Current : null, HandleCallbackOnUIThread = HandleCallbackOnUiThread, }; requestState.StartTimer(this.Timeout.GetValueOrDefault(DefaultTimeout)); SendWebRequestAsync(httpMethod, request, requestState, webRequest); }
public Task <TResponse> SendAsync <TResponse>(string httpMethod, string absoluteUrl, object request) { if (!httpMethod.HasRequestBody() && request != null) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { absoluteUrl += "?" + queryString; } } if (ResultsFilter != null) { var response = ResultsFilter(typeof(TResponse), httpMethod, absoluteUrl, request); if (response is TResponse) { var tcs = new TaskCompletionSource <TResponse>(); tcs.SetResult((TResponse)response); return(tcs.Task); } } var client = GetHttpClient(); if (AlwaysSendBasicAuthHeader) { AddBasicAuth(client); } this.PopulateRequestMetadata(request); var httpReq = new HttpRequestMessage(new HttpMethod(httpMethod), absoluteUrl); foreach (var name in Headers.AllKeys) { httpReq.Headers.Add(name, Headers[name]); } httpReq.Headers.Add(HttpHeaders.Accept, ContentType); if (httpMethod.HasRequestBody() && request != null) { var httpContent = request as HttpContent; if (httpContent != null) { httpReq.Content = httpContent; } else { var str = request as string; var bytes = request as byte[]; var stream = request as Stream; if (str != null) { httpReq.Content = new StringContent(str); } else if (bytes != null) { httpReq.Content = new ByteArrayContent(bytes); } else if (stream != null) { httpReq.Content = new StreamContent(stream); } else { using (__requestAccess()) { httpReq.Content = new StringContent(request.ToJson(), Encoding.UTF8, ContentType); } } } } ApplyWebRequestFilters(httpReq); Interlocked.Increment(ref activeAsyncRequests); if (CancelTokenSource == null) { CancelTokenSource = new CancellationTokenSource(); } var sendAsyncTask = client.SendAsync(httpReq, CancelTokenSource.Token); if (typeof(TResponse) == typeof(HttpResponseMessage)) { return((Task <TResponse>)(object) sendAsyncTask); } return(sendAsyncTask .ContinueWith(responseTask => { var httpRes = responseTask.Result; ApplyWebResponseFilters(httpRes); if (typeof(TResponse) == typeof(byte[])) { return httpRes.Content.ReadAsByteArrayAsync().ContinueWith(task => { ThrowIfError <TResponse>(task, httpRes, request, absoluteUrl, task.Result); var response = (TResponse)(object)task.Result; if (ResultsFilterResponse != null) { ResultsFilterResponse(httpRes, response, httpMethod, absoluteUrl, request); } return response; }); } if (typeof(TResponse) == typeof(Stream)) { return httpRes.Content.ReadAsStreamAsync().ContinueWith(task => { ThrowIfError <TResponse>(task, httpRes, request, absoluteUrl, task.Result); var response = (TResponse)(object)task.Result; if (ResultsFilterResponse != null) { ResultsFilterResponse(httpRes, response, httpMethod, absoluteUrl, request); } return response; }); } return httpRes.Content.ReadAsStringAsync().ContinueWith(task => { ThrowIfError <TResponse>(task, httpRes, request, absoluteUrl, task.Result); var body = task.Result; using (__requestAccess()) { var response = body.FromJson <TResponse>(); if (ResultsFilterResponse != null) { ResultsFilterResponse(httpRes, response, httpMethod, absoluteUrl, request); } return response; } }); }).Unwrap()); }
private WebRequest PrepareWebRequest(string httpMethod, string requestUri, object request, Action <HttpWebRequest> sendRequestAction) { if (httpMethod == null) { throw new ArgumentNullException("httpMethod"); } var httpMethodGetOrHead = httpMethod == HttpMethods.Get || httpMethod == HttpMethods.Head; if (httpMethodGetOrHead && request != null) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } var client = (HttpWebRequest)WebRequest.Create(requestUri); try { client.MaximumResponseHeadersLength = int.MaxValue; //throws "The message length limit was exceeded" exception client.Accept = Accept; client.Method = httpMethod; client.Headers.Add(Headers); if (Proxy != null) { client.Proxy = Proxy; } if (this.Timeout.HasValue) { client.Timeout = (int)this.Timeout.Value.TotalMilliseconds; } if (this.ReadWriteTimeout.HasValue) { client.ReadWriteTimeout = (int)this.ReadWriteTimeout.Value.TotalMilliseconds; } if (this.credentials != null) { client.Credentials = this.credentials; } if (null != this.authInfo) { client.AddAuthInfo(this.UserName, this.Password, authInfo); } else { if (this.AlwaysSendBasicAuthHeader) { client.AddBasicAuth(this.UserName, this.Password); } } if (!DisableAutoCompression) { client.Headers.Add(HttpRequestHeader.AcceptEncoding, "gzip,deflate"); client.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate; } if (StoreCookies) { client.CookieContainer = CookieContainer; } client.AllowAutoRedirect = AllowAutoRedirect; ApplyWebRequestFilters(client); if (httpMethod != HttpMethods.Get && httpMethod != HttpMethods.Delete && httpMethod != HttpMethods.Head) { client.ContentType = ContentType; if (sendRequestAction != null) { sendRequestAction(client); } } } catch (AuthenticationException ex) { throw WebRequestUtils.CreateCustomException(requestUri, ex) ?? ex; } return(client); }
public virtual TResponse PostFileWithRequest <TResponse>(string relativeOrAbsoluteUrl, Stream fileToUpload, string fileName, object request) { var requestUri = GetUrl(relativeOrAbsoluteUrl); var currentStreamPosition = fileToUpload.Position; Func <WebRequest> createWebRequest = () => { var webRequest = PrepareWebRequest(HttpMethods.Post, requestUri, null, null); var queryString = QueryStringSerializer.SerializeToString(request); #if !MONOTOUCH var nameValueCollection = System.Web.HttpUtility.ParseQueryString(queryString); #endif var boundary = DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture); webRequest.ContentType = "multipart/form-data; boundary=" + boundary; boundary = "--" + boundary; var newLine = "\r\n"; using (var outputStream = webRequest.GetRequestStream()) { #if !MONOTOUCH foreach (var key in nameValueCollection.AllKeys) { outputStream.Write(boundary + newLine); outputStream.Write("Content-Disposition: form-data;name=\"{0}\"{1}".FormatWith(key, newLine)); outputStream.Write("Content-Type: text/plain;charset=utf-8{0}{1}".FormatWith(newLine, newLine)); outputStream.Write(nameValueCollection[key] + newLine); } #endif outputStream.Write(boundary + newLine); outputStream.Write("Content-Disposition: form-data;name=\"{0}\";filename=\"{1}\"{2}{3}".FormatWith("upload", fileName, newLine, newLine)); var buffer = new byte[4096]; int byteCount; while ((byteCount = fileToUpload.Read(buffer, 0, 4096)) > 0) { outputStream.Write(buffer, 0, byteCount); } outputStream.Write(newLine); outputStream.Write(boundary + "--"); } return(webRequest); }; try { var webRequest = createWebRequest(); var webResponse = webRequest.GetResponse(); return(HandleResponse <TResponse>(webResponse)); } catch (Exception ex) { TResponse response; // restore original position before retry fileToUpload.Seek(currentStreamPosition, SeekOrigin.Begin); if (!HandleResponseException( ex, request, requestUri, createWebRequest, c => c.GetResponse(), out response)) { throw; } return(response); } }
public Task <TResponse> SendAsync <TResponse>(string httpMethod, string absoluteUrl, object request, CancellationToken token = default(CancellationToken)) { var client = GetHttpClient(); if (!HttpUtils.HasRequestBody(httpMethod) && request != null) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { absoluteUrl += "?" + queryString; } } try { absoluteUrl = new Uri(absoluteUrl).ToString(); } catch (Exception ex) { if (log.IsDebugEnabled) { log.Debug("Could not parse URL: " + absoluteUrl, ex); } } var response = ResultsFilter?.Invoke(typeof(TResponse), httpMethod, absoluteUrl, request); if (response is TResponse) { var tcs = new TaskCompletionSource <TResponse>(); tcs.SetResult((TResponse)response); return(tcs.Task); } if (token == default(CancellationToken)) { if (CancelTokenSource == null) { CancelTokenSource = new CancellationTokenSource(); } token = CancelTokenSource.Token; } var httpReq = CreateRequest(httpMethod, absoluteUrl, request); var sendAsyncTask = client.SendAsync(httpReq, token); if (typeof(TResponse) == typeof(HttpResponseMessage)) { return((Task <TResponse>)(object) sendAsyncTask); } return(sendAsyncTask .ContinueWith(responseTask => { var httpRes = responseTask.Result; if (httpRes.StatusCode == HttpStatusCode.Unauthorized) { if (RefreshToken != null) { var refreshDto = new GetAccessToken { RefreshToken = RefreshToken }; var uri = this.RefreshTokenUri ?? this.BaseUri.CombineWith(refreshDto.ToPostUrl()); return this.PostAsync <GetAccessTokenResponse>(uri, refreshDto) .ContinueWith(t => { if (t.IsFaulted) { if (t.Exception.UnwrapIfSingleException() is WebServiceException refreshEx) { throw new RefreshTokenException(refreshEx); } throw t.Exception; } var accessToken = t.Result?.AccessToken; if (string.IsNullOrEmpty(accessToken)) { throw new RefreshTokenException("Could not retrieve new AccessToken from: " + uri); } var refreshRequest = CreateRequest(httpMethod, absoluteUrl, request); if (this.GetTokenCookie() != null) { this.SetTokenCookie(accessToken); } else { refreshRequest.AddBearerToken(this.BearerToken = accessToken); } return client.SendAsync(refreshRequest, token).ContinueWith(refreshTask => ConvertToResponse <TResponse>(refreshTask.Result, httpMethod, absoluteUrl, refreshRequest, token), token).Unwrap(); }, token).Unwrap(); } if (UserName != null && Password != null && client.DefaultRequestHeaders.Authorization == null) { AddBasicAuth(client); httpReq = CreateRequest(httpMethod, absoluteUrl, request); sendAsyncTask = client.SendAsync(httpReq, token); return sendAsyncTask.ContinueWith(t => ConvertToResponse <TResponse>(t.Result, httpMethod, absoluteUrl, request, token), token).Unwrap(); } } return ConvertToResponse <TResponse>(httpRes, httpMethod, absoluteUrl, request, token); }, token).Unwrap()); }
private async Task <T> SendWebRequestAsync <T>(string httpMethod, string absoluteUrl, object request, CancellationToken token, bool recall = false) { if (httpMethod == null) { throw new ArgumentNullException(nameof(httpMethod)); } this.PopulateRequestMetadata(request); var requestUri = absoluteUrl; var hasQueryString = request != null && !HttpUtils.HasRequestBody(httpMethod); if (hasQueryString) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } var webReq = this.CreateHttpWebRequest(requestUri); if (webReq != null && Proxy != null) { webReq.Proxy = Proxy; } var timedOut = false; ITimer timer = null; timer = PclExportClient.Instance.CreateTimer(state => { timedOut = true; webReq?.Abort(); webReq = null; timer?.Cancel(); timer = null; }, this.Timeout.GetValueOrDefault(DefaultTimeout), this); Exception ResolveException(Exception ex) { if (token.IsCancellationRequested) { return(new OperationCanceledException(token)); } if (timedOut) { return(PclExportClient.Instance.CreateTimeoutException(ex, "The request timed out")); } return(ex); } bool returningWebResponse = false; HttpWebResponse webRes = null; T Complete(T response) { timer.Cancel(); PclExportClient.Instance.SynchronizeCookies(this); ResultsFilterResponse?.Invoke(webRes, response, httpMethod, absoluteUrl, request); return(response); } webReq.Accept = ContentType; if (this.EmulateHttpViaPost) { webReq.Method = "POST"; webReq.Headers[HttpHeaders.XHttpMethodOverride] = httpMethod; } else { webReq.Method = httpMethod; } PclExportClient.Instance.AddHeader(webReq, Headers); PclExport.Instance.Config(webReq, userAgent: UserAgent); if (this.authInfo != null && !string.IsNullOrEmpty(this.UserName)) { webReq.AddAuthInfo(this.UserName, this.Password, authInfo); } else if (this.BearerToken != null) { webReq.Headers[HttpHeaders.Authorization] = "Bearer " + this.BearerToken; } else if (this.Credentials != null) { webReq.Credentials = this.Credentials; } else if (this.AlwaysSendBasicAuthHeader) { webReq.AddBasicAuth(this.UserName, this.Password); } if (!DisableAutoCompression) { PclExport.Instance.AddCompression(webReq); } ApplyWebRequestFilters(webReq); try { if (HttpUtils.HasRequestBody(webReq.Method)) { webReq.ContentType = ContentType; if (RequestCompressionType != null) { webReq.Headers[HttpHeaders.ContentEncoding] = RequestCompressionType; } using var requestStream = await webReq.GetRequestStreamAsync().ConfigAwait(); token.ThrowIfCancellationRequested(); if (request != null) { StreamSerializer(null, request, requestStream); } } } catch (Exception ex) { if (Log.IsDebugEnabled) { Log.Debug($"Error Sending Request: {ex.Message}", ex); } throw HandleResponseError <T>(ResolveException(ex), requestUri, request); } try { webRes = (HttpWebResponse)await webReq.GetResponseAsync().ConfigAwait(); { token.ThrowIfCancellationRequested(); ApplyWebResponseFilters(webRes); returningWebResponse = typeof(T) == typeof(HttpWebResponse); if (returningWebResponse) { return(Complete((T)(object)webRes)); } var responseStream = webRes.ResponseStream(); var responseBodyLength = webRes.ContentLength; var bufferRead = new byte[BufferSize]; var totalRead = 0; int read; var ms = MemoryStreamFactory.GetStream(); while ((read = await responseStream.ReadAsync(bufferRead, 0, bufferRead.Length, token).ConfigAwait()) != 0) { await ms.WriteAsync(bufferRead, 0, read, token).ConfigAwait(); totalRead += read; OnDownloadProgress?.Invoke(totalRead, responseBodyLength); } try { ms.Position = 0; if (typeof(T) == typeof(Stream)) { return(Complete((T)(object)ms)); } else { var stream = ms; try { if (typeof(T) == typeof(string)) { return(Complete((T)(object)await stream.ReadToEndAsync().ConfigAwait())); } else if (typeof(T) == typeof(byte[])) { return(Complete((T)(object)stream.ToArray())); } else { return(Complete((T)this.StreamDeserializer(typeof(T), stream))); } } finally { if (stream.CanRead) { stream.Dispose(); // Not yet disposed, but could've been. } } } } catch (Exception ex) { if (Log.IsDebugEnabled) { Log.Debug($"Error Reading Response Error: {ex.Message}", ex); } throw; } finally { responseStream.Close(); } } } catch (Exception ex) { var webEx = ex as WebException; var firstCall = !recall; var hasRefreshTokenCookie = this.CookieContainer.GetRefreshTokenCookie(BaseUri) != null; var hasRefreshToken = RefreshToken != null || hasRefreshTokenCookie; if (firstCall && WebRequestUtils.ShouldAuthenticate(webEx, (!string.IsNullOrEmpty(UserName) && !string.IsNullOrEmpty(Password)) || Credentials != null || BearerToken != null || hasRefreshToken || OnAuthenticationRequired != null)) { try { if (hasRefreshToken) { var refreshRequest = new GetAccessToken { RefreshToken = RefreshToken, UseTokenCookie = UseTokenCookie, }; var uri = this.RefreshTokenUri ?? this.BaseUri.CombineWith(refreshRequest.ToPostUrl()); GetAccessTokenResponse tokenResponse; try { tokenResponse = (await uri.PostJsonToUrlAsync(refreshRequest, requestFilter: req => { if (UseTokenCookie || hasRefreshTokenCookie) { req.CookieContainer = CookieContainer; } }, token: token).ConfigAwait()).FromJson <GetAccessTokenResponse>(); } catch (WebException refreshEx) { var webServiceEx = ServiceClientBase.ToWebServiceException(refreshEx, stream => StreamDeserializer(typeof(T), stream), ContentType); if (webServiceEx != null) { throw new RefreshTokenException(webServiceEx); } throw new RefreshTokenException(refreshEx.Message, refreshEx); } var accessToken = tokenResponse?.AccessToken; var refreshClient = webReq = (HttpWebRequest)WebRequest.Create(requestUri); var tokenCookie = this.CookieContainer.GetTokenCookie(BaseUri); if (UseTokenCookie) { if (tokenCookie == null) { throw new RefreshTokenException("Could not retrieve new AccessToken Cooke from: " + uri); } refreshClient.CookieContainer.SetTokenCookie(BaseUri, tokenCookie); } else { if (string.IsNullOrEmpty(accessToken)) { throw new RefreshTokenException("Could not retrieve new AccessToken from: " + uri); } if (tokenCookie != null) { this.CookieContainer.SetTokenCookie(accessToken, BaseUri); refreshClient.CookieContainer.SetTokenCookie(BaseUri, accessToken); } else { refreshClient.AddBearerToken(this.BearerToken = accessToken); } } return(await SendWebRequestAsync <T>(httpMethod, absoluteUrl, request, token, recall : true).ConfigAwait()); } OnAuthenticationRequired?.Invoke(); var newReq = (HttpWebRequest)WebRequest.Create(requestUri); if (StoreCookies) { newReq.CookieContainer = CookieContainer; } HandleAuthException(ex, webReq); return(await SendWebRequestAsync <T>(httpMethod, absoluteUrl, request, token, recall : true).ConfigAwait()); } catch (WebServiceException) { throw; } catch (Exception /*subEx*/) { throw HandleResponseError <T>(ResolveException(ex), requestUri, request); } } if (ExceptionFilter != null && webEx?.Response != null) { var cachedResponse = ExceptionFilter(webEx, webEx.Response, requestUri, typeof(T)); if (cachedResponse is T variable) { return(variable); } } throw HandleResponseError <T>(ResolveException(ex), requestUri, request); } finally { if (!returningWebResponse) { webRes?.Dispose(); } } }
private WebRequest PrepareWebRequest(string httpMethod, string requestUri, object request, Action <HttpWebRequest> sendRequestAction) { if (httpMethod == null) { throw new ArgumentNullException("httpMethod"); } var httpMethodGetOrHead = httpMethod == HttpMethods.Get || httpMethod == HttpMethods.Head; if (httpMethodGetOrHead && request != null) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { requestUri += "?" + queryString; } } var client = (HttpWebRequest)WebRequest.Create(requestUri); try { client.Accept = Accept; client.Method = httpMethod; PclExportClient.Instance.AddHeader(client, Headers); #if !SL5 if (Proxy != null) { client.Proxy = Proxy; } #endif PclExport.Instance.Config(client, allowAutoRedirect: AllowAutoRedirect, timeout: this.Timeout, readWriteTimeout: ReadWriteTimeout, userAgent: UserAgent); if (this.credentials != null) { client.Credentials = this.credentials; } if (null != this.authInfo) { client.AddAuthInfo(this.UserName, this.Password, authInfo); } else { if (this.AlwaysSendBasicAuthHeader) { client.AddBasicAuth(this.UserName, this.Password); } } if (!DisableAutoCompression) { PclExport.Instance.AddCompression(client); } if (StoreCookies) { PclExportClient.Instance.SetCookieContainer(client, this); } ApplyWebRequestFilters(client); if (httpMethod != HttpMethods.Get && httpMethod != HttpMethods.Delete && httpMethod != HttpMethods.Head) { client.ContentType = ContentType; if (sendRequestAction != null) { sendRequestAction(client); } } } catch (AuthenticationException ex) { throw WebRequestUtils.CreateCustomException(requestUri, ex) ?? ex; } return(client); }
public Task <TResponse> SendAsync <TResponse>(string httpMethod, string absoluteUrl, object request, CancellationToken token = default(CancellationToken)) { var client = GetHttpClient(); if (!httpMethod.HasRequestBody() && request != null) { var queryString = QueryStringSerializer.SerializeToString(request); if (!string.IsNullOrEmpty(queryString)) { absoluteUrl += "?" + queryString; } } if (ResultsFilter != null) { var response = ResultsFilter(typeof(TResponse), httpMethod, absoluteUrl, request); if (response is TResponse) { var tcs = new TaskCompletionSource <TResponse>(); tcs.SetResult((TResponse)response); return(tcs.Task); } } if (token == default(CancellationToken)) { if (CancelTokenSource == null) { CancelTokenSource = new CancellationTokenSource(); } token = CancelTokenSource.Token; } var httpReq = CreateRequest(httpMethod, absoluteUrl, request); var sendAsyncTask = client.SendAsync(httpReq, token); if (typeof(TResponse) == typeof(HttpResponseMessage)) { return((Task <TResponse>)(object) sendAsyncTask); } return(sendAsyncTask .ContinueWith(responseTask => { var httpRes = responseTask.Result; if (httpRes.StatusCode == HttpStatusCode.Unauthorized) { if (RefreshToken != null) { var refreshDto = new GetAccessToken { RefreshToken = RefreshToken }; var uri = this.RefreshTokenUri ?? this.BaseUri.CombineWith(refreshDto.ToPostUrl()); return this.PostAsync <GetAccessTokenResponse>(uri, refreshDto) .ContinueWith(t => { var accessToken = t.Result?.AccessToken; if (string.IsNullOrEmpty(accessToken)) { throw new Exception("Could not retrieve new AccessToken from: " + uri); } var refreshRequest = CreateRequest(httpMethod, absoluteUrl, request); if (this.GetTokenCookie() != null) { this.SetTokenCookie(accessToken); } else { refreshRequest.AddBearerToken(this.BearerToken = accessToken); } return client.SendAsync(refreshRequest, token).ContinueWith(refreshTask => ConvertToResponse <TResponse>(refreshTask.Result, httpMethod, absoluteUrl, refreshRequest, token), token).Unwrap(); }, token).Unwrap(); } } return ConvertToResponse <TResponse>(httpRes, httpMethod, absoluteUrl, request, token); }, token).Unwrap()); }