produceTool/WDProduceTool/Utils/RestHelper.cs

using fastJSON;
using RestSharp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;

namespace WDProduceTool.Utils
{
    public sealed class RestHelper
    {
        /// <summary>
        /// params 
        /// </summary>
        private static RestClient _restClient;

        private static readonly RestHelper instance = new RestHelper();
        /// <summary>
        /// 显式的静态构造函数用来告诉C#编译器在其内容实例化之前不要标记其类型
        /// </summary>
        static RestHelper() { }
        private RestHelper() { }
        public static RestHelper Instance
        {
            get
            {
                return instance;
            }
        }
        public RestHelper InitRestClient()
        {
            _restClient = new RestClient();
            return instance;
        }

        public RestHelper InitRestClient(RestClientOptions options)
        {
            _restClient = new RestClient(options);
            return instance;
        }

        /// <summary>
        /// GET
        /// </summary>
        /// <param name="resource">资源</param>
        /// <returns>IRestResponse</returns>
        public async Task<RestResponse> GetAsync(string resource)
        {
            try
            {
                var request = new RestRequest(resource, Method.Get);
                RestResponse response = await _restClient.GetAsync(request);
                return response;
            }
            catch (Exception ex)
            {
                return null;
            }
        }



        /// <summary>
        /// GET
        /// 一般返回string或Enum
        /// </summary>
        /// <param name="resource">资源</param>
        /// <param name="obj">返回对象</param>
        /// <returns>true/false</returns>
        public bool Get(string resource, out object obj)
        {
            try
            {
                Task<RestResponse> response = GetAsync(resource);
                if (response.Result.StatusCode == HttpStatusCode.OK)
                {
                    obj = fastJSON.JSON.Parse(response.Result.Content);
                    return true;
                }
                else
                {
                    obj = null;
                    return false;
                }
            }
            catch (Exception ex)
            {
                obj = null;
                return false;
            }
        }


        /// <summary>
        /// GET返回T类型对象
        /// </summary>
        /// <typeparam name="T">存在无参构造函数</typeparam>
        /// <param name="resource">资源</param>
        /// <returns>T</returns>
        public Task<RestResponse<T>> Get<T>(string resource) where T : new()
        {
            try
            {
                var request = new RestRequest(resource, Method.Get);
                return _restClient.ExecuteAsync<T>(request);
            }
            catch (Exception ex)
            {
                return null;
            }
        }

        /// <summary>
        /// GET返回T类型对象
        /// </summary>
        /// <typeparam name="T">存在无参构造函数</typeparam>
        /// <param name="resource">资源</param>
        /// <param name="isData">是否使用IRestResponse<T>.Data</param>
        /// <returns>T</returns>
        public T Get<T>(string resource, bool isData) where T : new()
        {
            try
            {
                var request = new RestRequest(resource, Method.Get);
                request.AddHeader("Content-Type", "application/json;charset=UTF-8");
                request.Timeout = 100000;
                Task<RestResponse<T>> response = _restClient.ExecuteAsync<T>(request);

                if (response.Result.StatusCode != HttpStatusCode.OK)
                    return default(T);
                if (isData)
                {
                    if (response.Result.Data != null)
                        return response.Result.Data;
                }

                return JSON.ToObject<T>(response.Result.Content);
            }
            catch (Exception ex)
            {
                return default(T);
            }
        }



        /// <summary>
        /// GET返回T类型对象
        /// </summary>
        /// <typeparam name="T">存在无参构造函数的类型</typeparam>
        /// <param name="resource">资源</param>
        /// <param name="parameters">参数列表</param>
        /// <returns>T</returns>
        public T Get<T>(string resource, List<Parameter> parameters) where T : new()
        {
            try
            {
                var request = new RestRequest(resource, Method.Get);
                foreach (var param in parameters)
                {
                    request.AddParameter(param);
                }
                Task<RestResponse<T>> response = _restClient.ExecuteAsync<T>(request);
                if (response.Result.Data != null)
                    return response.Result.Data;

                return JSON.ToObject<T>(response.Result.Content);

            }

            catch (Exception ex)
            {
                return default(T);
            }
        }



        /// <summary>
        /// GET返回T类型对象
        /// </summary>
        /// <typeparam name="T">存在无参构造函数的类型</typeparam>
        /// <param name="resource">资源</param>
        /// <param name="queryParam">参数列表</param>
        /// <param name="isData">是否使用response.Data</param>
        /// <returns>T</returns>
        public T Get<T>(string resource, Dictionary<string, string> queryParam, bool isData = false) where T : new()
        {
            try
            {
                var request = new RestRequest(resource, Method.Get);
                foreach (var param in queryParam)
                {
                    request.AddQueryParameter(param.Key, param.Value);
                }

                var response = _restClient.ExecuteAsync<T>(request);

                if (isData)
                    return response.Result.Data;

                return JSON.ToObject<T>(response.Result.Content);
            }
            catch (Exception ex)
            {
                return default(T);
            }

        }



        /// <summary>
        /// POST
        /// </summary>
        /// <param name="resource">resource</param>
        /// <param name="obj">body参数</param>
        /// <returns>HttpStatusCode</returns>
        public HttpStatusCode Post(string resource, object obj)
        {
            try
            {
                var request = new RestRequest(resource, Method.Post) { RequestFormat = DataFormat.Json };

                request.AddHeader("Content-Type", "application/json"); //设置HTTP头
                request.AddBody(obj);//account实体类的一个对象
                return _restClient.ExecutePostAsync(request).Result.StatusCode;
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
        /// <summary>
        /// postJons数据
        /// </summary>
        /// <typeparam name="T">返回值泛型</typeparam>
        /// <param name="resource">请求路径</param>
        /// <param name="obj">发送的数据</param>
        /// <returns></returns>

        public Task<RestResponse<T>> Post<T>(string resource, Object obj) where T : new()
        {
            try
            {
                var request = new RestRequest(resource).AddJsonBody(obj);
                
                var response = _restClient.ExecutePostAsync<T>(request);
                //var response = _restClient.ExecuteAsync(request);

                return response;
            }
            catch (Exception ex)
            {
                return null;
            }

        }


    }

}