示例#1
0
        /// <summary>
        /// 发送请求数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="urlArguments">Url构造器</param>
        /// <param name="method">请求类型</param>
        /// <param name="contentCall">HttpContent请求内容</param>
        /// <param name="mediaType">mediaType数据格式,请求格式和返回格式一致(JSON、MessagePack)</param>
        /// <param name="cancellationToken">取消令牌</param>
        /// <returns></returns>
        public virtual async Task <T> HttpSendAsync <T>(UrlArguments urlArguments, HttpMethod method, Func <HttpContent> contentCall, HttpMediaType mediaType = HttpMediaType.Json, CancellationToken cancellationToken = default)
            where T : class, new()
        {
            HttpClient client = HttpClientFactory.CreateClient(string.IsNullOrEmpty(urlArguments.ClientName) ? "apiClient" : urlArguments.ClientName);

            string requestUrl = urlArguments.Complete().Url;

            string _mediaType = mediaType.Description();

            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(_mediaType));

            HttpResponseMessage responseMessage = null;

            if (client.BaseAddress == null)
            {
                HttpRequestMessage requestMessage = new HttpRequestMessage
                {
                    Method     = method,
                    RequestUri = new Uri(requestUrl)
                };

                foreach (var accept in client.DefaultRequestHeaders.Accept)
                {
                    requestMessage.Headers.Accept.Add(accept);
                }

                requestMessage.Headers.Authorization = client.DefaultRequestHeaders.Authorization;

                RequestHeaders(requestMessage.Headers);

                requestMessage.Content = contentCall?.Invoke();
                //if (requestMessage.Content != null)
                //    requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);

                responseMessage = await client.SendAsync(requestMessage, cancellationToken);
            }
            else
            {
                RequestHeaders(client.DefaultRequestHeaders);

                HttpContent content = contentCall?.Invoke();
                //if (content != null)
                //    content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);

                responseMessage = await SendAsync(client, requestUrl, method, content, cancellationToken);
            }

            switch (mediaType)
            {
            case HttpMediaType.MessagePack:
            {
                var res = await responseMessage.Content.ReadAsByteArrayAsync();

                if (_logger.IsEnabled(LogLevel.Information))
                {
                    _logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType:{_mediaType},Method:{method.Method},HttpMessage Read Byte Data Length:{res.Length}");
                }

                return(res.ToMsgPackObject <T>());
            }

            case HttpMediaType.MessagePackJackson:
            {
                var res = await responseMessage.Content.ReadAsStringAsync();

                if (_logger.IsEnabled(LogLevel.Debug))
                {
                    _logger.LogDebug($"{client.BaseAddress}{requestUrl} MediaType:{_mediaType},Method:{method.Method},HttpMessage Read Jackson Data:{res}");
                }

                return(res.ToMsgPackBytesFromJson().ToMsgPackObject <T>());
            }

            default:
            {
                var res = await responseMessage.Content.ReadAsStringAsync();

                if (_logger.IsEnabled(LogLevel.Information))
                {
                    _logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType:{_mediaType},Method:{method.Method},HttpMessage Read Json Data:{res}");
                }

                return(res.ToObject <T>());
            }
            }
        }