MESProductionWeb/AntORM/Ant.Common/SOA/SOACommon.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

namespace Ant.Common
{
    public class SOACommon
    {
        /// <summary>
        /// 抽象接口调用方法
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="apiurl"></param>
        /// <param name="method"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public async static Task<dynamic> GetDataAsync<T>(string apiurl, string method, int timeout = 3000)
        {
            HttpClient client = new HttpClient
            {
                BaseAddress = new Uri(apiurl),
                Timeout = TimeSpan.FromMilliseconds(timeout)
            };

            using (var response = await client.GetAsync(method))
            {
                if (response.IsSuccessStatusCode)
                {
                    var reslut = await response.Content.ReadAsAsync<T>();
                    return reslut;
                }
                else
                {//进行轮询下一个服务器的URL进行调用

                }
                return null;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="apiurl"></param>
        /// <param name="method"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public async static Task<dynamic> GetDynamicAsync(string apiurl, string method, int timeout = 3000)
        {
            HttpClient httpClient = new HttpClient()
            {
                BaseAddress = new Uri(apiurl),
                Timeout = TimeSpan.FromMilliseconds(timeout)
            };
            // 创建一个异步GET请求，当请求返回时继续处理
            await httpClient.GetAsync(method).ContinueWith(
                (requestTask) =>
                {
                    HttpResponseMessage response = requestTask.Result;
                    // 确认响应成功，否则抛出异常
                    response.EnsureSuccessStatusCode();
                    // 异步读取响应为字符串
                    response.Content.ReadAsStringAsync().ContinueWith(
                         (readTask) =>
                         {
                             var relsut = readTask.Result;
                             return relsut;
                         });
                });
            return null;
        }


        /// <summary>
        /// POST请求通过请求JOSN字符串后返回也是JOSN字符串
        /// </summary>
        /// <param name="apiurl"></param>
        /// <param name="method"></param>
        /// <param name="josnString"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public async static Task<string> PostDataAsync(string apiurl, string method, string josnString, int timeout = 3000)
        {
            HttpContent httpContent = new StringContent(josnString);
            httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");

            HttpClient httpClient = new HttpClient
            {
                BaseAddress = new Uri(apiurl),
                Timeout = TimeSpan.FromMilliseconds(timeout)
            };
            using (var response = await httpClient.PostAsync(method, httpContent))
            {
                if (response.IsSuccessStatusCode)
                {
                    Task<string> reslut = response.Content.ReadAsStringAsync();
                    return reslut.Result;
                }
            }
            return string.Empty;
        }
        /// <summary>
        /// POST请求通过实体对象传递返回也是实体对象
        /// </summary>
        /// <typeparam name="Response"></typeparam>
        /// <typeparam name="Request"></typeparam>
        /// <param name="apiurl"></param>
        /// <param name="method"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public async static Task<dynamic> PostDataAsync<Response, Request>(string apiurl, string method, Request t, int timeout = 3000)
        {
            var josnString = JsonConvert.SerializeObject(t);
            HttpContent httpContent = new StringContent(josnString);
            httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            HttpClient httpClient = new HttpClient
            {
                BaseAddress = new Uri(apiurl),
                Timeout = TimeSpan.FromMilliseconds(timeout)
            };
            using (var response = await httpClient.PostAsync(method, httpContent))
            {
                if (response.IsSuccessStatusCode)
                {
                    Task<string> reslut = response.Content.ReadAsStringAsync();
                    var modlist = JsonConvert.DeserializeObject<Response>(reslut.Result);
                    return modlist;
                }
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="apiurl"></param>
        /// <param name="method"></param>
        /// <param name="content"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public async static Task<dynamic> PostDataAsync<T>(string apiurl, string method, HttpContent content, int timeout = 3000)
        {
            HttpClient client = new HttpClient
            {
                BaseAddress = new Uri(apiurl),
                Timeout = TimeSpan.FromMilliseconds(timeout)
            };
            using (var response = await client.PostAsync(method, content))
            {
                var reslut = await response.Content.ReadAsAsync<T>();
                return reslut;
            }
        }
    }

}