public async Task <List <SelectedItem> > CallItemsApi(string url, HttpMethodEnum method = HttpMethodEnum.GET, object postdata = null, int?timeout = null, string proxy = null, string placeholder = null, List <string> values = null) { var result = await CallAPI <List <ComboSelectListItem> >(url, method, postdata, timeout, proxy); List <SelectedItem> rv = new List <SelectedItem>(); if (values == null) { values = new List <string>(); } if (result.StatusCode == System.Net.HttpStatusCode.OK) { if (result.Data != null) { foreach (var item in result.Data) { rv.Add(new SelectedItem { Text = item.Text, Value = item.Value.ToString(), Active = values.Any(x => x.Contains(item.Value.ToString())) }); } } if (string.IsNullOrEmpty(placeholder) == false) { rv.Insert(0, new SelectedItem { Text = placeholder, Value = "" }); } } return(rv); }
/// <summary> /// Do not invoke. Is invoked by the server with every request /// </summary> public async Task <bool> Process(string path, HttpMethodEnum method, Request req, Response res) { if (!_settings.ShouldAuthenticate(path)) { return(true); } string token = null; string auth = req.Headers["Authorization"]; if (string.IsNullOrEmpty(auth)) { await _settings.OnNotAuthenticated(req, res); return(false); } if (auth.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase)) { token = auth.Substring("Bearer ".Length).Trim(); } if (string.IsNullOrEmpty(token) || !TryAuthenticateToken(token, out var session)) { await _settings.OnNotAuthenticated(req, res); return(false); } req.SetData(session.Data); return(true); }
public static string DoRequest(string url, HttpMethodEnum method, string content) { HttpWebRequest request = CreateHttpRequest(url, method); if (request != null) { if (method != HttpMethodEnum.GET) { byte[] datas = Encoding.UTF8.GetBytes(content); request.ContentLength = datas.Length; using (BinaryWriter sw = new BinaryWriter(request.GetRequestStream())) { sw.Write(datas); } } HttpWebResponse response = request.GetResponse() as HttpWebResponse; if (response != null) { using (StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8)) { string data = sr.ReadToEnd(); return(data); } } } return(null); }
public RequestFilter(HttpMethodEnum allowedMethods, Regex urlPattern, Func <IRequest, Match, Task <IResponse> > requestTransform) { AllowedMethods = allowedMethods; UrlPattern = urlPattern; RequestTransform = requestTransform; }
public virtual async Task <StringBuilder> GetResourceData(Uri resourceUrl, HttpMethodEnum requestType, Dictionary <string, string> requestContent = null) { StringBuilder result = null; try { Task <HttpResponseMessage> serverResponceTask = null; switch (requestType) { case HttpMethodEnum.GET: var getParams = string.Empty; if (requestContent != null && requestContent.Any()) { var firstElement = requestContent.First(); getParams += string.Format("?{0}={1}", firstElement.Key, firstElement.Value); foreach (var el in requestContent.Skip(1)) { getParams += string.Format("&{0}={1}", el.Key, el.Value); } } serverResponceTask = WebClient.GetAsync(resourceUrl + getParams); break; case HttpMethodEnum.PUT: serverResponceTask = WebClient.PutAsync(resourceUrl, new FormUrlEncodedContent(requestContent)); break; case HttpMethodEnum.POST: serverResponceTask = WebClient.PostAsync(resourceUrl, new FormUrlEncodedContent(requestContent)); break; } if (serverResponceTask != null) { var serverDataResult = await(await serverResponceTask).Content.ReadAsStringAsync(); result = new StringBuilder(serverDataResult); #if DEBUG File.WriteAllText("C:\\webResource.html", serverDataResult); #endif } } catch (Exception ex) { Logger.LogException(ex, LogTypeEnum.CORE, string.Format("GetResourceData for {0} parser failed, URL: {1}, RequestType: {2}, RequestContent: {3}", GetType().Name, resourceUrl.AbsoluteUri, requestType, requestContent == null ? string.Empty : requestContent.Aggregate(string.Empty, (agg, el) => agg + string.Format("Key: {0}, Value: {1}", el.Key, el.Value)))); } return(result); }
public HttpClient(string endpoint, HttpMethodEnum method, string postData, string userName, string password) { UrlEndPoint = endpoint; Method = method; PostData = postData; UserName = userName; Password = password; }
public IRequest CreateRequest(string content, string route = "", HttpMethodEnum method = HttpMethodEnum.Get) { var request = A.Fake <IRequest>(); A.CallTo(() => request.Url).Returns(new Uri(HttpPrefix + route)); A.CallTo(() => request.Content).Returns(content); A.CallTo(() => request.HttpMethod).Returns(method); return(request); }
/// <summary> /// Do not invoke. Is invoked by the server with every request /// </summary> public async Task <bool> Process(string path, HttpMethodEnum method, Request req, Response res) { if (_settings.ShouldAuthenticate(path)) { return(await Authenticate(req, res)); } return(true); }
/// <summary> /// Envía una petición a la url especificada con las opciones /// de configuración requerida /// </summary> /// <typeparam name="T">Tipo de dato a esperado</typeparam> /// <param name="Url">Url destino</param> /// <param name="Method">Tipo de método de la petición</param> /// <param name="Data">Objeto a enviar en la petición</param> /// <param name="TimeOut">Tiempo de espera en minutos</param> /// <returns></returns> internal static HttpResponse <T> Request <T>(string Url, HttpMethodEnum Method, object Data = null, int TimeOut = 1) { var Response = new HttpResponse <T>(); T Value = default(T); HttpStatusCode HttpStatus = HttpStatusCode.OK; using (HttpClient client = new HttpClient()) { try { client.Timeout = TimeSpan.FromMinutes(TimeOut); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = null; switch (Method) { case HttpMethodEnum.Get: response = client.GetAsync(Url).Result; break; case HttpMethodEnum.PostJson: response = client.PostAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.PutJson: response = client.PutAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.Delete: response = client.DeleteAsync(Url).Result; break; default: break; } if (response.StatusCode == HttpStatusCode.OK) { Value = response.Content.ReadAsAsync <T>().Result; } HttpStatus = response.StatusCode; } catch (Exception ex) { // Excepciones Value = default(T); Response.StatusCode = HttpStatusCode.InternalServerError; Response.Exception = ex; } } Response.Value = Value; Response.StatusCode = HttpStatus; return(Response); }
/// <summary> /// Envía una petición a la url especificada con las opciones /// de configuración requerida /// </summary> /// <typeparam name="T">Tipo de dato a esperado</typeparam> /// <param name="Url">Url destino</param> /// <param name="Method">Tipo de método de la petición</param> /// <param name="Data">Objeto a enviar en la petición</param> /// <param name="TimeOut">Tiempo de espera en minutos</param> /// <returns></returns> public static T Request <T>(string Url, HttpMethodEnum Method, object Data = null, string Token = null, int TimeOut = 10) { using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient()) { try { client.Timeout = TimeSpan.FromMinutes(TimeOut); client.DefaultRequestHeaders.Accept.Add( new MediaTypeWithQualityHeaderValue("application/json")); client.DefaultRequestHeaders.Accept.Add( new MediaTypeWithQualityHeaderValue("text/plain")); if (!string.IsNullOrEmpty(Token)) { client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token); } HttpResponseMessage response = null; switch (Method) { case HttpMethodEnum.Get: response = client.GetAsync(Url).Result; break; case HttpMethodEnum.PostJson: response = client.PostAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.PutJson: response = client.PutAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.Delete: response = client.DeleteAsync(Url).Result; break; default: break; } if (response.IsSuccessStatusCode) { T result = response.Content.ReadAsAsync <T>().Result; return(result); } else { return(default(T)); } } catch (Exception ex) { // Excepciones throw ex; } } }
/// <summary> /// Builds the request message serializing data. /// </summary> /// <param name="method">HTTP method to use when making the request.</param> /// <param name="url">URL to send request message.</param> /// <param name="data">Object containing data to be sent.</param> /// <param name="headers">Headers of request message.</param> /// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param> /// <returns>The <see cref="HttpRequestMessage"/> object.</returns> private HttpRequestMessage BuildRequestMessage(HttpMethodEnum method, string url, object data, NameValueCollection headers, HttpRequestOptions options) { var requestMessage = new HttpRequestMessage(new HttpMethod(method.ToString()), url) { Content = Utils.CreateHttpContent(data, options) }; SetRequestHeaders(requestMessage, headers); return(requestMessage); }
/// <summary> /// 调用远程地址 /// </summary> /// <param name="url">地址</param> /// <param name="method">请求方式</param> /// <param name="postdata">Post数据</param> /// <param name="timeout">超时秒数</param> /// <param name="proxy">代理</param> /// <param name="settings">jsonSerializerSettings</param> /// <returns>远程方法返回的内容</returns> public static string CallAPI( string url, HttpMethodEnum method = HttpMethodEnum.GET, IDictionary <string, string> postdata = null, int?timeout = null, string proxy = null, JsonSerializerSettings settings = null ) { return(CallAPIAsync(url, method, postdata, timeout, proxy).Result); }
public void GetQueryParamsDecoded(string requestUrl, HttpMethodEnum httpMethodEnum) { // Arrange var httpMethod = this.MethodFromEnum(httpMethodEnum); var requestMessage = new HttpRequestMessage(httpMethod, requestUrl); // Act var result = this.requestService.GetQueryParamsDecoded(requestMessage); // Assert }
/// <summary> /// Sends an HTTP request message, gets the reponse and tries to deserialize it to a given type. /// </summary> /// <remarks> /// When both request-specific timeout and default timeout are set, the shorter one will apply. /// In other words, if timeoutInSeconds is greater than default timeout, the default will be used. /// </remarks> /// <typeparam name="TResponse">Type to deserialize the response body.</typeparam> /// <param name="url">URL to send request message.</param> /// <param name="method">HTTP method to use when making the request.</param> /// <param name="data">Object containing data to be sent or null when a body is not required.</param> /// <param name="headers">Headers of request message.</param> /// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param> /// <returns><see cref="Response{TResponse}"/> with data from HTTP response.</returns> public async Task <Response <TResponse> > SendAsync <TResponse>(HttpMethodEnum method, string url, object data = null, NameValueCollection headers = null, HttpRequestOptions options = null) { if (options == null) { options = new HttpRequestOptions(); } var response = await SendAsync(method, url, data, headers, options); var deserializedResponseBody = Utils.TryDeserializeResponseBody <TResponse>(response.Headers, response.ResponseBody, options.NamingStrategy, options.NullValueHandling); return(new Response <TResponse>(response, deserializedResponseBody)); }
/// <summary> /// 调用远程方法,返回强类型 /// </summary> /// <typeparam name="T">返回类型</typeparam> /// <param name="url">地址</param> /// <param name="method">请求方式</param> /// <param name="postdata">Post数据</param> /// <param name="timeout">超时秒数</param> /// <param name="proxy">代理</param> /// <param name="settings">jsonSerializerSettings</param> /// <returns>强类型</returns> public static T CallAPI <T>( string url, HttpMethodEnum method = HttpMethodEnum.GET, IDictionary <string, string> postdata = null, int?timeout = null, string proxy = null, JsonSerializerSettings settings = null ) { var s = CallAPI(url, method, postdata, timeout, proxy); return(JsonDeserialize <T>(s)); }
public ResultMessage RequestApi(string url, HttpMethodEnum httpMethod) { ResultMessage resultMessage = new ResultMessage { IsSuccess = true, Code = 0, Data = null, ErrMessage = string.Empty }; using (HttpClient httpClient = new HttpClient()) { HttpRequestMessage httpRequestMessage = new HttpRequestMessage(); HttpMethod method = null; switch (httpMethod) { case HttpMethodEnum.Get: method = HttpMethod.Get; break; case HttpMethodEnum.Post: method = HttpMethod.Post; break; case HttpMethodEnum.Delete: method = HttpMethod.Delete; break; case HttpMethodEnum.Put: method = HttpMethod.Put; break; default: throw new Exception("不存在的类型"); } httpRequestMessage.RequestUri = new Uri(url); httpRequestMessage.Method = method; httpRequestMessage.Headers.Add("Access-Control-Allow-Origin", "*");//支持跨域 var result = httpClient.SendAsync(httpRequestMessage).Result; try { var context = result.Content.ReadAsStringAsync().Result; resultMessage.Data = context; resultMessage.Code = result.StatusCode; return(resultMessage); } catch (Exception ex) { resultMessage.IsSuccess = false; resultMessage.ErrMessage = ex.Message; resultMessage.Code = result.StatusCode; return(resultMessage); } } }
private HttpMethod MethodFromEnum(HttpMethodEnum httpMethodEnum) { switch (httpMethodEnum) { case HttpMethodEnum.Get: return(HttpMethod.Get); case HttpMethodEnum.Post: return(HttpMethod.Post); default: return(HttpMethod.Get); } }
/// <summary> /// Envía una petición a la url especificada con las opciones /// de configuración requerida /// </summary> /// <typeparam name="T">Tipo de dato a esperado</typeparam> /// <param name="Url">Url destino</param> /// <param name="Method">Tipo de método de la petición</param> /// <param name="Data">Objeto a enviar en la petición</param> /// <param name="TimeOut">Tiempo de espera en minutos</param> /// <returns></returns> internal static T Request <T>(string Url, HttpMethodEnum Method, object Data = null, int TimeOut = 1) { using (HttpClient client = new HttpClient()) { try { client.Timeout = TimeSpan.FromMinutes(TimeOut); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = null; switch (Method) { case HttpMethodEnum.Get: response = client.GetAsync(Url).Result; break; case HttpMethodEnum.PostJson: response = client.PostAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.PutJson: response = client.PutAsJsonAsync(Url, Data).Result; break; case HttpMethodEnum.Delete: response = client.DeleteAsync(Url).Result; break; default: break; } if (response.IsSuccessStatusCode) { T result = response.Content.ReadAsAsync <T>().Result; return(result); } else { return(default(T)); } } catch (Exception ex) { // Excepciones return(default(T)); } } }
private static HttpWebRequest CreateHttpRequest(string url, HttpMethodEnum method, int timeout = 5) { HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest; if (request != null) { request.Method = method.ToString(); //request.ContentType = "application/json; charset=UTF-8"; request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36"; request.Timeout = 3000; request.ServicePoint.Expect100Continue = false; } return(request); }
/// <summary> /// Sends an HTTP request message and gets the reponse (as string). /// </summary> /// <remarks> /// When both request-specific timeout and default timeout are set, the shorter one will apply. /// In other words, if timeoutInSeconds is greater than default timeout, the default will be used. /// </remarks> /// <param name="url">URL to send request message.</param> /// <param name="method">HTTP method to use when making the request.</param> /// <param name="data">Object containing data to be sent or null when a body is not required.</param> /// <param name="headers">Headers of request message.</param> /// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param> /// <returns><see cref="Response{TResponse}"/> with data from HTTP response.</returns> public async Task <Response> SendAsync(HttpMethodEnum method, string url, object data = null, NameValueCollection headers = null, HttpRequestOptions options = null) { SetActiveConnectionTimeout(url); // This will allow a DNS lookup periodically since HttpClient is static. if (options == null) { options = new HttpRequestOptions(); } using (var requestMessage = BuildRequestMessage(method, url, data, headers, options)) { return(await SendRequestAsync(requestMessage, options.TimeoutInSeconds)); } }
private Task <HttpResponseMessage> PostDataAsync(HttpMethodEnum method, string url, HttpContent content) { switch (method) { case HttpMethodEnum.POST: return(httpClient.PostAsync(url, content)); case HttpMethodEnum.PUT: return(httpClient.PutAsync(url, content)); case HttpMethodEnum.DELETE: return(httpClient.DeleteAsync(url)); } return(httpClient.PostAsync(url, content)); }
public static T ConfigureAndExecute <T>(APIContext apiContext, HttpMethodEnum httpMethod, string resource, string payload) { if (apiContext == null) { throw new Exception("APIContext object is null"); } Dictionary <string, string> config = apiContext.Config; string resourcePath = resource; Dictionary <string, string> httpHeaders = apiContext.HTTPHeaders; string requestId = apiContext.RequestId; IAPICallPreHandler iApiCallPreHandler = Helper.CreateIAPICallPreHandler(config, httpHeaders, requestId, payload); return(Helper.ConfigureAndExecute <T>(config, iApiCallPreHandler, httpMethod, resourcePath)); }
public async Task <string> HttpRequest(HttpClient client, string url, HttpMethodEnum httpMethod, string data = null, Dictionary <string, string> headers = null, string contentType = "application/json") { client ??= httpClient; string result = string.Empty; try { HttpResponseMessage response = null; if (httpMethod == HttpMethodEnum.POST) { HttpContent content = new StringContent(data ?? "", Encoding.UTF8, contentType); if (headers != null) { foreach (var h in headers) { content.Headers.Add(h.Key, h.Value); } } response = await client.PostAsync(url, content); } else if (httpMethod == HttpMethodEnum.GET) { response = await client.GetAsync(url); } if (response != null && response.StatusCode == System.Net.HttpStatusCode.OK) { result = await response.Content.ReadAsStringAsync(); } } catch (Exception e) { var ex = e; if (e.InnerException != null) { if (e.InnerException.InnerException != null) { ex = e.InnerException.InnerException; } else { ex = e.InnerException; } } throw ex; } return(result); }
public static string GetToken(HttpMethodEnum method, string url, HeaderCollection headers, string contentType, string body, string tokenPath, Guid tokenId, int tokenExpiresIn, bool cachedToken) { if (!string.IsNullOrEmpty(body) & string.IsNullOrEmpty(contentType)) { throw new ArgumentNullException("ContentType cannot be null or empty when Body is specified", "contentType"); } if (string.IsNullOrEmpty(tokenPath)) { throw new ArgumentNullException("TokenPath cannot be null", "tokenPath"); } string token = null; if (cachedToken) { if (tokenExpiresIn <= 0) { throw new ArgumentException("tokenExpiresIn must have a value greater than zero.", "tokenExpiresIn"); } if (tokenId == null || tokenId == Guid.Empty) { throw new ArgumentException("Invalid tokenId", "tokenId"); } TokenInfo ti = AppDomainHelper.TokenDictionary.GetOrCreateTokenInfo(tokenId, tokenExpiresIn); lock (ti) { if (ti.IsNew || !ti.IsValid | !cachedToken) { token = GetToken(method, url, headers, contentType, body, tokenPath); ti.SetTokenInfo(token, DateTime.Now); TokenDictionary.WriteLogMessage(message: $"Get new token for TokenId '{tokenId}'.", procName: "Cached Token"); } else { token = ti.Token; TokenDictionary.WriteLogMessage(message: $"Get token for TokenId '{tokenId}' from cache.", procName: "Cached Token"); } } } else { token = GetToken(method, url, headers, contentType, body, tokenPath); TokenDictionary.WriteLogMessage(message: $"Get new token", procName: "No Cache"); } return(token); }
/// <summary> /// Http请求基础方法 /// </summary> /// <param name="Url"></param> /// <param name="HttpMethod"></param> /// <param name="ContentType"></param> /// <param name="data"></param> /// <returns></returns> private async Task<byte[]> HttpRequest(string Url, HttpMethodEnum HttpMethod, string ContentType, byte[] data) { byte[] result = null; try { HttpResponseMessage message = null; if (HttpMethod == HttpMethodEnum.POST) { using (Stream dataStream = new MemoryStream(data ?? new byte[0])) { using (HttpContent content = new StreamContent(dataStream)) { content.Headers.Add("Content-Type", ContentType); message = await _http.PostAsync(Url, content); } } } else if (HttpMethod == HttpMethodEnum.GET) { message =await _http.GetAsync(Url); } //处理返回的数据 using (message) { using (var responseStream = await message.Content.ReadAsStreamAsync()) { if (responseStream != null) { byte[] responseData = new byte[responseStream.Length]; responseStream.Read(responseData, 0, responseData.Length); result = responseData; } } } } catch (Exception ex) { Log.Error(ex); return new byte[0]; } return result; }
public SecurityTokenHelperBehavior(string authEndpoint, HttpMethodEnum method, HeaderCollection headers, string contentType, string body, string tokenPath, string tokenKey, string tokenPrefix, string tokenSuffix, TokenUsageEnum tokenUsage, Guid tokenId, bool cacheToken, int tokenExpiresIn) { this.AuthEndpoint = authEndpoint; this.HttpMethod = method; this.Headers = headers; this.TokenPath = tokenPath; this.ContentType = contentType; this.Body = body; this.TokenKey = tokenKey; this.TokenPrefix = tokenPrefix; this.TokenSuffix = tokenSuffix; this.TokenUsage = tokenUsage; this.CacheToken = cacheToken; this.TokenId = tokenId; this.TokenExpiresIn = tokenExpiresIn; }
/// <summary> /// /// </summary> /// <typeparam name="T"></typeparam> /// <param name="domainName">Appsettings中配置的Domain key</param> /// <param name="url">调用地址</param> /// <param name="method">调用方式</param> /// <param name="postdata">提交字段</param> /// <param name="timeout">超时时间,单位秒</param> /// <param name="proxy">代理地址</param> /// <returns></returns> public async Task <ApiResult <T> > CallAPI <T>(string url, HttpMethodEnum method, IDictionary <string, string> postdata, int?timeout = null, string proxy = null) where T : class { HttpContent content = null; //填充表单数据 if (!(postdata == null || postdata.Count == 0)) { List <KeyValuePair <string, string> > paras = new List <KeyValuePair <string, string> >(); foreach (string key in postdata.Keys) { paras.Add(new KeyValuePair <string, string>(key, postdata[key])); } if (paras.Any()) { url = url.AppendQuery(paras); } content = new FormUrlEncodedContent(paras); } return(await CallAPI <T>(url, method, content, timeout, proxy)); }
public async Task <ApiResult <T> > CallAPI <T>(string url, HttpMethodEnum method, IDictionary <string, string> postdata, byte[] filedata, string filename, int?timeout = null, string proxy = null) where T : class { MultipartFormDataContent content = new MultipartFormDataContent(); //填充表单数据 if (!(postdata == null || postdata.Count == 0)) { List <KeyValuePair <string, string> > paras = new List <KeyValuePair <string, string> >(); foreach (string key in postdata.Keys) { if (postdata[key] != null) { content.Add(new StringContent(postdata[key]), key); } } } content.Add(new ByteArrayContent(filedata), "File", filename); return(await CallAPI <T>(url, method, content, timeout, proxy)); }
async Task <TOutput> CallWebApiAsync <TInput, TOutput>(TInput input, string endpoint, HttpMethodEnum method, CancellationToken cancellationToken) where TInput : class { return(await Task.Run(async() => { HttpContent content = null; if (input != null) { content = await SerializeContent <TInput>(input, endpoint); } var startupUri = new Uri(endpoint); HttpResponseMessage response = null; switch (method) { case HttpMethodEnum.Get: response = await _client.GetAsync(endpoint, cancellationToken); break; case HttpMethodEnum.Post: response = await _client.PostAsync(endpoint, content, cancellationToken); break; case HttpMethodEnum.Put: response = await _client.PutAsync(endpoint, content, cancellationToken); break; case HttpMethodEnum.Delete: response = await _client.DeleteAsync(endpoint, cancellationToken); break; default: break; } return await ManageBackendResponse <TOutput>(endpoint, response); }, cancellationToken)); }
async Task <TOutput> CallWebApiAsync <TOutput>(string endpoint, HttpMethodEnum method, CancellationToken cancellationToken) { return(await Task.Run(async() => { HttpContent content = null; #if DEBUG System.Diagnostics.Debug.WriteLine($"{endpoint} Request {method}"); #endif var startupUri = new Uri(endpoint); HttpResponseMessage response = null; switch (method) { case HttpMethodEnum.Get: response = await _client.GetAsync(endpoint, cancellationToken); break; case HttpMethodEnum.Post: response = await _client.PostAsync(endpoint, content, cancellationToken); break; case HttpMethodEnum.Put: response = await _client.PutAsync(endpoint, content, cancellationToken); break; case HttpMethodEnum.Delete: response = await _client.DeleteAsync(endpoint, cancellationToken); break; default: break; } return await ManageBackendResponse <TOutput>(endpoint, response); }, cancellationToken)); }