asp.net webpi 中使用 ClientHelper 发起HTTP请求

1：nuget 程序集:RestSharp, Version=106.3.1.0, Culture=neutral, PublicKeyToken=598062e77f915f75

2:类库代码:ClientHelper

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

namespace test.Common
{
    /// <summary>
    /// Http请求操作类
    /// </summary>
    public class ClientHelper
    {
        public RestClient Client { get; set; }

        #region
        public ClientHelper() : this("")
        {
        }

        public ClientHelper(string baseUrl)
        {
            this.Client = new RestClient(baseUrl);
        }

        public ClientHelper(Uri baseUrl)
        {
            this.Client = new RestClient(baseUrl);
        }

        public ClientHelper(Uri baseUrl, int timeout)
        {
            this.Client = new RestClient(baseUrl);
            this.Client.Timeout = timeout;
        }
        #endregion

        #region Base
        public virtual IRestResponse Execute(IRestRequest request)
        {
            //IRestResponse response = client.Execute(request);
            //var content = response.Content; // raw content as string
            return this.Client.Execute(request);
        }
        public virtual IRestResponse<T> Execute<T>(IRestRequest request) where T : new()
        {
            //IRestResponse<Person> response2 = client.Execute<Person>(request);
            //var name = response2.Data.Name;
            return this.Client.Execute<T>(request);
        }

        public virtual RestRequestAsyncHandle ExecuteAsync(IRestRequest request, Action<IRestResponse, RestRequestAsyncHandle> callback)
        {
            //IRestResponse response = client.Execute(request);
            //var content = response.Content; // raw content as string
            return this.Client.ExecuteAsync(request, callback);
        }
        public virtual RestRequestAsyncHandle ExecuteAsync<T>(IRestRequest request, Action<IRestResponse<T>, RestRequestAsyncHandle> callback)
        {
            //var asyncHandle = client.ExecuteAsync<Person>(request, response => {
            //    Console.WriteLine(response.Data.Name);
            //});
            return this.Client.ExecuteAsync<T>(request, callback);
        }
        #endregion

        #region 
        public virtual IRestResponse Execute(string resource, Method method, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            RestRequest request = new RestRequest(resource, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            return this.Client.Execute(request);
        }

        public virtual IRestResponse ExecuteGet(string resource, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.Execute(resource, Method.GET, paramObj, headerObj);
        }

        public virtual IRestResponse ExecutePost(string resource, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.Execute(resource, Method.POST, paramObj, headerObj);
        }

        public virtual IRestResponse ExecutePut(string resource, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.Execute(resource, Method.PUT, paramObj, headerObj);
        }

        public virtual IRestResponse ExecuteDelete(string resource, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.Execute(resource, Method.DELETE, paramObj, headerObj);
        }

        public virtual IRestResponse<T> Execute<T>(string resource, Method method, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            RestRequest request = new RestRequest(resource, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            return this.Client.Execute<T>(request);
        }

        public virtual IRestResponse<T> ExecuteGet<T>(string resource, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.Execute<T>(resource, Method.GET, paramObj, headerObj);
        }

        public virtual IRestResponse<T> ExecutePost<T>(string resource, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.Execute<T>(resource, Method.POST, paramObj, headerObj);
        }

        public virtual IRestResponse<T> ExecutePut<T>(string resource, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.Execute<T>(resource, Method.PUT, paramObj, headerObj);
        }

        public virtual IRestResponse<T> ExecuteDelete<T>(string resource, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.Execute<T>(resource, Method.DELETE, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecuteAsync(string resource, Method method, Action<IRestResponse, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            //IRestResponse response = client.Execute(request);
            //var content = response.Content; // raw content as string
            RestRequest request = new RestRequest(resource, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            return this.Client.ExecuteAsync(request, callback);

        }

        public virtual RestRequestAsyncHandle ExecuteGetAsync(string resource, Action<IRestResponse, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync(resource, Method.GET, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecutePostAsync(string resource, Action<IRestResponse, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync(resource, Method.POST, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecutePutAsync(string resource, Action<IRestResponse, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync(resource, Method.PUT, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecuteDeleteAsync(string resource, Action<IRestResponse, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync(resource, Method.DELETE, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecuteAsync<T>(string resource, Method method, Action<IRestResponse<T>, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            //var asyncHandle = client.ExecuteAsync<Person>(request, response =>
            //{
            //    Console.WriteLine(response.Data.Name);
            //});
            RestRequest request = new RestRequest(resource, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            return this.Client.ExecuteAsync<T>(request, callback);
        }

        public virtual RestRequestAsyncHandle ExecuteGetAsync<T>(string resource, Action<IRestResponse<T>, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync<T>(resource, Method.GET, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecutePostAsync<T>(string resource, Action<IRestResponse<T>, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync<T>(resource, Method.POST, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecutePutAsync<T>(string resource, Action<IRestResponse<T>, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync<T>(resource, Method.PUT, callback, paramObj, headerObj);
        }

        public virtual RestRequestAsyncHandle ExecuteDeleteAsync<T>(string resource, Action<IRestResponse<T>, RestRequestAsyncHandle> callback, object paramObj = null, IDictionary<string, string> headerObj = null)
        {
            return this.ExecuteAsync<T>(resource, Method.DELETE, callback, paramObj, headerObj);
        }
        #endregion

        #region 
        protected void RestRequestWithParam(IRestRequest request, Method method, object paramObj)
        {
            if (paramObj != null)
            {
                switch (method)
                {
                    case Method.GET:
                        request.AddObject(paramObj);
                        break;
                    case Method.POST:
                        request.AddObject(paramObj);
                        break;
                    case Method.PUT:
                        request.AddJsonBody(paramObj);
                        break;
                    case Method.DELETE:
                        request.AddObject(paramObj);
                        break;
                    default:
                        request.AddObject(paramObj);
                        break;
                }
            }
        }

        protected void RestRequestWithHeader(IRestRequest request, IDictionary<string, string> headerObj)
        {
            if (headerObj != null)
            {
                foreach (KeyValuePair<string, string> item in headerObj)
                {
                    request.AddHeader(item.Key, item.Value);
                }
            }
        }
        #endregion
    }
}

　　3:使用  BaseClientHelper继承ClientHelper

 public class BaseClientHelper : ClientHelper
    {
        #region
        public BaseClientHelper() : this("")
        {
        }

        public BaseClientHelper(string baseUrl) : base(baseUrl)
        {
            this.Client = new RestClient(baseUrl);
        }

        public BaseClientHelper(Uri baseUrl) : base(baseUrl)
        {
            this.Client = new RestClient(baseUrl);
        }

        public BaseClientHelper(Uri baseUrl, int timeout) : base(baseUrl, timeout)
        {
            this.Client = new RestClient(baseUrl);
            this.Client.Timeout = timeout;
        }
        #endregion

        public BaseResponse<T> ExecuteSingle<T>(string url, Method method, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            var request = new RestRequest(url, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            IRestResponse<BaseResponse<T>> response = this.Client.Execute<BaseResponse<T>>(request);

            return response.Data as BaseResponse<T>;
        }

        public BaseResponse<T> ExecuteGetSingle<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteSingle<T>(url, Method.GET, paramObj, headerObj);
        }

        public BaseResponse<T> ExecutePostSingle<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteSingle<T>(url, Method.POST, paramObj, headerObj);
        }

        public BaseResponse<T> ExecutePutSingle<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteSingle<T>(url, Method.PUT, paramObj, headerObj);
        }

        public BaseResponse<T> ExecuteDeleteSingle<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteSingle<T>(url, Method.DELETE, paramObj, headerObj);
        }

        public BaseResponseList<T> ExecuteList<T>(string url, Method method, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            var request = new RestRequest(url, method);

            RestRequestWithParam(request, method, paramObj);

            RestRequestWithHeader(request, headerObj);

            IRestResponse<BaseResponseList<T>> response = this.Client.Execute<BaseResponseList<T>>(request);

            return response.Data as BaseResponseList<T>;
        }

        public BaseResponseList<T> ExecuteGetList<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteList<T>(url, Method.GET, paramObj, headerObj);
        }

        public BaseResponseList<T> ExecutePostList<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteList<T>(url, Method.POST, paramObj, headerObj);
        }

        public BaseResponseList<T> ExecutePutList<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteList<T>(url, Method.PUT, paramObj, headerObj);
        }

        public BaseResponseList<T> ExecuteDeleteList<T>(string url, object paramObj = null, IDictionary<string, string> headerObj = null) where T : new()
        {
            return this.ExecuteList<T>(url, Method.DELETE, paramObj, headerObj);
        }

    }

　　4:调用

  BaseClientHelper clientHelper = new BaseClientHelper(ConfigurationManager.AppSettings["PI"]);

IDictionary<string, string> headerObj = new Dictionary<string, string>();
headerObj.Add("X-USER-LOGINNAME", "0");

 result = clientEabyHelper.ExecutePostSingle<bool>("/api/EbayBehand/Email/SendEvaluationLink", null, headerObj);