/// <summary> /// constructor, create new instance of HttpSender /// </summary> /// <param name="client">System.Net.Http.HttpClient</param> /// <param name="options"></param> /// <param name="logger">Microsoft.Extensions.Logging.ILogger</param> /// <param name="responseFactory"></param> /// protected HttpSenderBase(HttpClient client, HttpSenderOptions options, IResponseFactory responseFactory, ILogger logger) { _client = client; _options = options; _logger = logger; ResponseFactory = responseFactory; }
/// <inheritdoc/> protected override HttpContent CreateContent <T>(T body, HttpSenderOptions options) { if (body is byte[] bytes) { return(HttpSenderHelper.CreateByteArrayContent(bytes)); } return(HttpSenderHelper.CreateStringContent(Serialize(body, options), true)); }
/// <inheritdoc/> protected override string Serialize <T>(T obj, HttpSenderOptions options) { if (obj == null) { return(string.Empty); } if (obj is string s) { return(s); } return(JsonConvert.SerializeObject(obj, options.JsonParseSettings.Serializing)); }
/// <inheritdoc/> protected override IResponse <T> Deserialize <T>(string str, HttpSenderOptions options) { var jBody = JToken.Parse(str); if (options.ValidateErrorsInResponse && TryExtractErrorFromBody(jBody, out var err)) { return(ResponseFactory.CreateFault <T>(err)); } var result = jBody.ToObject <T>(JsonSerializer.Create(options.JsonParseSettings.Deserializing)); return(ResponseFactory.CreateSuccess(result)); }
private IResponse <T> DoDeserialize <T>(string str, HttpSenderOptions options) where T : new() { if (string.IsNullOrEmpty(str)) { return(ResponseFactory.CreateSuccess(new T())); } if (typeof(T).IsValueType || typeof(T) == typeof(string)) { return(ResponseFactory.CreateSuccess((T)Convert.ChangeType(str, typeof(T)))); } return(Deserialize <T>(str, options)); }
/// <inheritdoc/> protected override IResponse <T> Deserialize <T>(string str, HttpSenderOptions options) { var doc = XDocument.Parse(str); if (options.ValidateErrorsInResponse && TryExtractErrorFromBody(doc, out var err)) { return(ResponseFactory.CreateFault <T>(err)); } if (options.XmlParseSettings.Deserialize.RemoveEmptyElements) { XmlUtils.RemoveEmptyElementsFrom(doc); } if (options.XmlParseSettings.Deserialize.RemoveNilElements) { doc.RemoveNilElements(); } return(ResponseFactory.CreateSuccess(XmlUtils.CastXDocumentToObj <T>(doc))); }
/// <summary> /// /// </summary> /// <param name="requestType"></param> /// <param name="apiMethod"></param> /// <param name="body"></param> /// <param name="cancel"></param> /// <param name="cfgAction"></param> /// <typeparam name="TReq"></typeparam> /// <typeparam name="TResp"></typeparam> /// <returns></returns> public async Task <IResponse <TResp> > SendHttpRequest <TReq, TResp>(HttpMethod requestType, string apiMethod, TReq body, CancellationToken cancel = default, Action <HttpSenderOptions, CustomHttpHeaders> cfgAction = default) where TResp : new() { HttpSenderOptions options; var headers = new CustomHttpHeaders(); if (cfgAction == default) { options = _options; } else { options = new HttpSenderOptions(); cfgAction.Invoke(options, headers); } var content = DoCreateContent(body, options); return(await SendHttpRequest <TResp>(requestType, apiMethod, content, cancel, options, headers)); }
/// <inheritdoc/> protected override string Serialize <T>(T obj, HttpSenderOptions options) { if (obj == null) { return(string.Empty); } if (obj is string s) { return(s); } var doc = XmlUtils.CastObjToXDocument(obj); if (options.XmlParseSettings.Serialize.RemoveEmptyElements) { XmlUtils.RemoveEmptyElementsFrom(doc); } if (options.XmlParseSettings.Serialize.RemoveNilElements) { doc.RemoveNilElements(); } return(doc.ToString()); }
/// <summary> /// constructor, create new instance of HttpSender /// </summary> /// <param name="client">System.Net.Http.HttpClient</param> /// <param name="options">http sender ext params</param> /// <param name="responseFactory"></param> /// <param name="logger">Microsoft.Extensions.Logging.ILogger</param> protected HttpSenderXml(HttpClient client, HttpSenderOptions options, IResponseFactory responseFactory, ILogger <HttpSenderXml> logger) : base(client, options, responseFactory, logger) { }
internal static void PutHttpSenderOptionsInPool <T>(this IServiceCollection services, HttpSenderOptions options) { services.TryAddSingleton <IHttpSenderOptionsPool>(HttpSenderOptionsPool.CreateInstance()); var pool = services.BuildServiceProvider().GetService <IHttpSenderOptionsPool>(); if (pool == null) { throw new ArgumentNullException(); } pool.Put <T>(options); }
/// <summary> /// create request content by body type /// <param name="body">object query</param> /// <param name="options">options</param> /// </summary> /// <returns>stringr</returns> protected abstract HttpContent CreateContent <T>(T body, HttpSenderOptions options);
/// <summary> /// serialize http request class to string /// <param name="obj">object to serializing</param> /// <param name="options">serialize options</param> /// </summary> /// <returns>stringr</returns> protected abstract string Serialize <T>(T obj, HttpSenderOptions options);
// where TOut : IFail, new(); /// <summary> /// deserialize http response body to class /// <param name="str">string to deserializing</param> /// <param name="options">deserialize options</param> /// </summary> /// <returns>T resolver</returns> protected abstract IResponse <T> Deserialize <T>(string str, HttpSenderOptions options) where T : new();
private HttpContent DoCreateContent <T>(T body, HttpSenderOptions options) { return(body == null ? null : CreateContent(body, options)); }
/// <summary> /// /// </summary> /// <param name="requestType"></param> /// <param name="apiMethod"></param> /// <param name="content"></param> /// <param name="cancel"></param> /// <param name="options"></param> /// <param name="headers"></param> /// <typeparam name="TResp"></typeparam> /// <returns></returns> public async Task <IResponse <TResp> > SendHttpRequest <TResp>(HttpMethod requestType, string apiMethod, HttpContent content, CancellationToken cancel = default, HttpSenderOptions options = default, CustomHttpHeaders headers = default) where TResp : new() { var uri = new Uri(_client.BaseAddress, apiMethod); var senderOptions = options ?? _options ?? new HttpSenderOptions(); var senderHeaders = headers ?? new CustomHttpHeaders(); using (var request = new HttpRequestMessage(requestType, uri)) { request.Content = content; request.AppendHeaders(senderHeaders); using (var cts = HttpSenderHelper.CreateCancellationTokenSource(senderOptions.RequestTimeout, cancel)) { try { _logger.LogDebug($"Request: [{requestType.ToString().ToUpper()}] {uri.AbsoluteUri}"); _logger.LogDebug(await content.ReadAsStringAsync()); var response = await _client.SendAsync(request, cts?.Token ?? cancel); var bodyAsStr = await HttpSenderHelper.ExtractBodyAsync(response.Content); _logger.LogDebug("Response: " + bodyAsStr); return(HasNotOkStatusCode(response) ? ResponseFactory.CreateFault <TResp>(new HttpFail(response.StatusCode, response.ReasonPhrase)) : DoDeserialize <TResp>(bodyAsStr, senderOptions)); } catch (OperationCanceledException oex) { var errMsg = cancel.IsCancellationRequested ? $"Client cancel task: {oex.Message}" : $"Connection timeout: {oex.Message}"; return(ResponseFactory.CreateFault <TResp>(new HttpFail(errMsg))); } catch (Exception ex) { return(ResponseFactory.CreateFault <TResp>(new HttpFail(ex.Message, ex.InnerException))); } } } }