public async Task <List <SelectedItem> > CallItemsApi(string url, HttpMethodEnum method = HttpMethodEnum.GET, object postdata = null, int?timeout = null, string proxy = null, string placeholder = null, List <string> values = null)
{
var result = await CallAPI <List <ComboSelectListItem> >(url, method, postdata, timeout, proxy);
List <SelectedItem> rv = new List <SelectedItem>();
if (values == null)
{
values = new List <string>();
}
if (result.StatusCode == System.Net.HttpStatusCode.OK)
{
if (result.Data != null)
{
foreach (var item in result.Data)
{
rv.Add(new SelectedItem
{
Text = item.Text,
Value = item.Value.ToString(),
Active = values.Any(x => x.Contains(item.Value.ToString()))
});
}
}
if (string.IsNullOrEmpty(placeholder) == false)
{
rv.Insert(0, new SelectedItem
{
Text = placeholder,
Value = ""
});
}
}
return(rv);
}
/// <summary>
/// Do not invoke. Is invoked by the server with every request
/// </summary>
public async Task <bool> Process(string path, HttpMethodEnum method, Request req, Response res)
{
if (!_settings.ShouldAuthenticate(path))
{
return(true);
}
string token = null;
string auth = req.Headers["Authorization"];
if (string.IsNullOrEmpty(auth))
{
await _settings.OnNotAuthenticated(req, res);
return(false);
}
if (auth.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
{
token = auth.Substring("Bearer ".Length).Trim();
}
if (string.IsNullOrEmpty(token) || !TryAuthenticateToken(token, out var session))
{
await _settings.OnNotAuthenticated(req, res);
return(false);
}
req.SetData(session.Data);
return(true);
}
public static string DoRequest(string url, HttpMethodEnum method, string content)
{
HttpWebRequest request = CreateHttpRequest(url, method);
if (request != null)
{
if (method != HttpMethodEnum.GET)
{
byte[] datas = Encoding.UTF8.GetBytes(content);
request.ContentLength = datas.Length;
using (BinaryWriter sw = new BinaryWriter(request.GetRequestStream()))
{
sw.Write(datas);
}
}
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
if (response != null)
{
using (StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
{
string data = sr.ReadToEnd();
return(data);
}
}
}
return(null);
}
public RequestFilter(HttpMethodEnum allowedMethods, Regex urlPattern,
Func <IRequest, Match, Task <IResponse> > requestTransform)
{
AllowedMethods = allowedMethods;
UrlPattern = urlPattern;
RequestTransform = requestTransform;
}
public virtual async Task <StringBuilder> GetResourceData(Uri resourceUrl, HttpMethodEnum requestType, Dictionary <string, string> requestContent = null)
{
StringBuilder result = null;
try
{
Task <HttpResponseMessage> serverResponceTask = null;
switch (requestType)
{
case HttpMethodEnum.GET:
var getParams = string.Empty;
if (requestContent != null && requestContent.Any())
{
var firstElement = requestContent.First();
getParams += string.Format("?{0}={1}", firstElement.Key, firstElement.Value);
foreach (var el in requestContent.Skip(1))
{
getParams += string.Format("&{0}={1}", el.Key, el.Value);
}
}
serverResponceTask = WebClient.GetAsync(resourceUrl + getParams);
break;
case HttpMethodEnum.PUT:
serverResponceTask = WebClient.PutAsync(resourceUrl, new FormUrlEncodedContent(requestContent));
break;
case HttpMethodEnum.POST:
serverResponceTask = WebClient.PostAsync(resourceUrl, new FormUrlEncodedContent(requestContent));
break;
}
if (serverResponceTask != null)
{
var serverDataResult = await(await serverResponceTask).Content.ReadAsStringAsync();
result = new StringBuilder(serverDataResult);
#if DEBUG
File.WriteAllText("C:\\webResource.html", serverDataResult);
#endif
}
}
catch (Exception ex)
{
Logger.LogException(ex, LogTypeEnum.CORE,
string.Format("GetResourceData for {0} parser failed, URL: {1}, RequestType: {2}, RequestContent: {3}",
GetType().Name,
resourceUrl.AbsoluteUri,
requestType,
requestContent == null
? string.Empty
: requestContent.Aggregate(string.Empty, (agg, el) => agg + string.Format("Key: {0}, Value: {1}", el.Key, el.Value))));
}
return(result);
}
public HttpClient(string endpoint, HttpMethodEnum method, string postData, string userName, string password)
{
UrlEndPoint = endpoint;
Method = method;
PostData = postData;
UserName = userName;
Password = password;
}
public IRequest CreateRequest(string content, string route = "", HttpMethodEnum method = HttpMethodEnum.Get)
{
var request = A.Fake <IRequest>();
A.CallTo(() => request.Url).Returns(new Uri(HttpPrefix + route));
A.CallTo(() => request.Content).Returns(content);
A.CallTo(() => request.HttpMethod).Returns(method);
return(request);
}
/// <summary>
/// Do not invoke. Is invoked by the server with every request
/// </summary>
public async Task <bool> Process(string path, HttpMethodEnum method, Request req, Response res)
{
if (_settings.ShouldAuthenticate(path))
{
return(await Authenticate(req, res));
}
return(true);
}
/// <summary>
/// Envía una petición a la url especificada con las opciones
/// de configuración requerida
/// </summary>
/// <typeparam name="T">Tipo de dato a esperado</typeparam>
/// <param name="Url">Url destino</param>
/// <param name="Method">Tipo de método de la petición</param>
/// <param name="Data">Objeto a enviar en la petición</param>
/// <param name="TimeOut">Tiempo de espera en minutos</param>
/// <returns></returns>
internal static HttpResponse <T> Request <T>(string Url, HttpMethodEnum Method, object Data = null, int TimeOut = 1)
{
var Response = new HttpResponse <T>();
T Value = default(T);
HttpStatusCode HttpStatus = HttpStatusCode.OK;
using (HttpClient client = new HttpClient())
{
try
{
client.Timeout = TimeSpan.FromMinutes(TimeOut);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = null;
switch (Method)
{
case HttpMethodEnum.Get:
response = client.GetAsync(Url).Result;
break;
case HttpMethodEnum.PostJson:
response = client.PostAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.PutJson:
response = client.PutAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.Delete:
response = client.DeleteAsync(Url).Result;
break;
default:
break;
}
if (response.StatusCode == HttpStatusCode.OK)
{
Value = response.Content.ReadAsAsync <T>().Result;
}
HttpStatus = response.StatusCode;
}
catch (Exception ex)
{
// Excepciones
Value = default(T);
Response.StatusCode = HttpStatusCode.InternalServerError;
Response.Exception = ex;
}
}
Response.Value = Value;
Response.StatusCode = HttpStatus;
return(Response);
}
/// <summary>
/// Envía una petición a la url especificada con las opciones
/// de configuración requerida
/// </summary>
/// <typeparam name="T">Tipo de dato a esperado</typeparam>
/// <param name="Url">Url destino</param>
/// <param name="Method">Tipo de método de la petición</param>
/// <param name="Data">Objeto a enviar en la petición</param>
/// <param name="TimeOut">Tiempo de espera en minutos</param>
/// <returns></returns>
public static T Request <T>(string Url, HttpMethodEnum Method, object Data = null, string Token = null, int TimeOut = 10)
{
using (System.Net.Http.HttpClient client = new System.Net.Http.HttpClient())
{
try
{
client.Timeout = TimeSpan.FromMinutes(TimeOut);
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Accept.Add(
new MediaTypeWithQualityHeaderValue("text/plain"));
if (!string.IsNullOrEmpty(Token))
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token);
}
HttpResponseMessage response = null;
switch (Method)
{
case HttpMethodEnum.Get:
response = client.GetAsync(Url).Result;
break;
case HttpMethodEnum.PostJson:
response = client.PostAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.PutJson:
response = client.PutAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.Delete:
response = client.DeleteAsync(Url).Result;
break;
default:
break;
}
if (response.IsSuccessStatusCode)
{
T result = response.Content.ReadAsAsync <T>().Result;
return(result);
}
else
{
return(default(T));
}
}
catch (Exception ex)
{
// Excepciones
throw ex;
}
}
}
/// <summary>
/// Builds the request message serializing data.
/// </summary>
/// <param name="method">HTTP method to use when making the request.</param>
/// <param name="url">URL to send request message.</param>
/// <param name="data">Object containing data to be sent.</param>
/// <param name="headers">Headers of request message.</param>
/// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param>
/// <returns>The <see cref="HttpRequestMessage"/> object.</returns>
private HttpRequestMessage BuildRequestMessage(HttpMethodEnum method, string url, object data, NameValueCollection headers, HttpRequestOptions options)
{
var requestMessage = new HttpRequestMessage(new HttpMethod(method.ToString()), url)
{
Content = Utils.CreateHttpContent(data, options)
};
SetRequestHeaders(requestMessage, headers);
return(requestMessage);
}
/// <summary>
/// 调用远程地址
/// </summary>
/// <param name="url">地址</param>
/// <param name="method">请求方式</param>
/// <param name="postdata">Post数据</param>
/// <param name="timeout">超时秒数</param>
/// <param name="proxy">代理</param>
/// <param name="settings">jsonSerializerSettings</param>
/// <returns>远程方法返回的内容</returns>
public static string CallAPI(
string url,
HttpMethodEnum method = HttpMethodEnum.GET,
IDictionary <string, string> postdata = null,
int?timeout = null,
string proxy = null,
JsonSerializerSettings settings = null
)
{
return(CallAPIAsync(url, method, postdata, timeout, proxy).Result);
}
public void GetQueryParamsDecoded(string requestUrl, HttpMethodEnum httpMethodEnum)
{
// Arrange
var httpMethod = this.MethodFromEnum(httpMethodEnum);
var requestMessage = new HttpRequestMessage(httpMethod, requestUrl);
// Act
var result = this.requestService.GetQueryParamsDecoded(requestMessage);
// Assert
}
/// <summary>
/// Sends an HTTP request message, gets the reponse and tries to deserialize it to a given type.
/// </summary>
/// <remarks>
/// When both request-specific timeout and default timeout are set, the shorter one will apply.
/// In other words, if timeoutInSeconds is greater than default timeout, the default will be used.
/// </remarks>
/// <typeparam name="TResponse">Type to deserialize the response body.</typeparam>
/// <param name="url">URL to send request message.</param>
/// <param name="method">HTTP method to use when making the request.</param>
/// <param name="data">Object containing data to be sent or null when a body is not required.</param>
/// <param name="headers">Headers of request message.</param>
/// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param>
/// <returns><see cref="Response{TResponse}"/> with data from HTTP response.</returns>
public async Task <Response <TResponse> > SendAsync <TResponse>(HttpMethodEnum method, string url, object data = null, NameValueCollection headers = null, HttpRequestOptions options = null)
{
if (options == null)
{
options = new HttpRequestOptions();
}
var response = await SendAsync(method, url, data, headers, options);
var deserializedResponseBody = Utils.TryDeserializeResponseBody <TResponse>(response.Headers, response.ResponseBody, options.NamingStrategy, options.NullValueHandling);
return(new Response <TResponse>(response, deserializedResponseBody));
}
/// <summary>
/// 调用远程方法，返回强类型
/// </summary>
/// <typeparam name="T">返回类型</typeparam>
/// <param name="url">地址</param>
/// <param name="method">请求方式</param>
/// <param name="postdata">Post数据</param>
/// <param name="timeout">超时秒数</param>
/// <param name="proxy">代理</param>
/// <param name="settings">jsonSerializerSettings</param>
/// <returns>强类型</returns>
public static T CallAPI <T>(
string url,
HttpMethodEnum method = HttpMethodEnum.GET,
IDictionary <string, string> postdata = null,
int?timeout = null,
string proxy = null,
JsonSerializerSettings settings = null
)
{
var s = CallAPI(url, method, postdata, timeout, proxy);
return(JsonDeserialize <T>(s));
}
public ResultMessage RequestApi(string url, HttpMethodEnum httpMethod)
{
ResultMessage resultMessage = new ResultMessage {
IsSuccess = true, Code = 0, Data = null, ErrMessage = string.Empty
};
using (HttpClient httpClient = new HttpClient())
{
HttpRequestMessage httpRequestMessage = new HttpRequestMessage();
HttpMethod method = null;
switch (httpMethod)
{
case HttpMethodEnum.Get:
method = HttpMethod.Get;
break;
case HttpMethodEnum.Post:
method = HttpMethod.Post;
break;
case HttpMethodEnum.Delete:
method = HttpMethod.Delete;
break;
case HttpMethodEnum.Put:
method = HttpMethod.Put;
break;
default:
throw new Exception("不存在的类型");
}
httpRequestMessage.RequestUri = new Uri(url);
httpRequestMessage.Method = method;
httpRequestMessage.Headers.Add("Access-Control-Allow-Origin", "*");//支持跨域
var result = httpClient.SendAsync(httpRequestMessage).Result;
try
{
var context = result.Content.ReadAsStringAsync().Result;
resultMessage.Data = context;
resultMessage.Code = result.StatusCode;
return(resultMessage);
}
catch (Exception ex)
{
resultMessage.IsSuccess = false;
resultMessage.ErrMessage = ex.Message;
resultMessage.Code = result.StatusCode;
return(resultMessage);
}
}
}
private HttpMethod MethodFromEnum(HttpMethodEnum httpMethodEnum)
{
switch (httpMethodEnum)
{
case HttpMethodEnum.Get:
return(HttpMethod.Get);
case HttpMethodEnum.Post:
return(HttpMethod.Post);
default:
return(HttpMethod.Get);
}
}
/// <summary>
/// Envía una petición a la url especificada con las opciones
/// de configuración requerida
/// </summary>
/// <typeparam name="T">Tipo de dato a esperado</typeparam>
/// <param name="Url">Url destino</param>
/// <param name="Method">Tipo de método de la petición</param>
/// <param name="Data">Objeto a enviar en la petición</param>
/// <param name="TimeOut">Tiempo de espera en minutos</param>
/// <returns></returns>
internal static T Request <T>(string Url, HttpMethodEnum Method, object Data = null, int TimeOut = 1)
{
using (HttpClient client = new HttpClient())
{
try
{
client.Timeout = TimeSpan.FromMinutes(TimeOut);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
HttpResponseMessage response = null;
switch (Method)
{
case HttpMethodEnum.Get:
response = client.GetAsync(Url).Result;
break;
case HttpMethodEnum.PostJson:
response = client.PostAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.PutJson:
response = client.PutAsJsonAsync(Url, Data).Result;
break;
case HttpMethodEnum.Delete:
response = client.DeleteAsync(Url).Result;
break;
default:
break;
}
if (response.IsSuccessStatusCode)
{
T result = response.Content.ReadAsAsync <T>().Result;
return(result);
}
else
{
return(default(T));
}
}
catch (Exception ex)
{
// Excepciones
return(default(T));
}
}
}
private static HttpWebRequest CreateHttpRequest(string url, HttpMethodEnum method, int timeout = 5)
{
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
if (request != null)
{
request.Method = method.ToString();
//request.ContentType = "application/json; charset=UTF-8";
request.UserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.135 Safari/537.36";
request.Timeout = 3000;
request.ServicePoint.Expect100Continue = false;
}
return(request);
}
/// <summary>
/// Sends an HTTP request message and gets the reponse (as string).
/// </summary>
/// <remarks>
/// When both request-specific timeout and default timeout are set, the shorter one will apply.
/// In other words, if timeoutInSeconds is greater than default timeout, the default will be used.
/// </remarks>
/// <param name="url">URL to send request message.</param>
/// <param name="method">HTTP method to use when making the request.</param>
/// <param name="data">Object containing data to be sent or null when a body is not required.</param>
/// <param name="headers">Headers of request message.</param>
/// <param name="options">Advanced request options. See <see cref="HttpRequestOptions"/> for more details.</param>
/// <returns><see cref="Response{TResponse}"/> with data from HTTP response.</returns>
public async Task <Response> SendAsync(HttpMethodEnum method, string url, object data = null, NameValueCollection headers = null, HttpRequestOptions options = null)
{
SetActiveConnectionTimeout(url);
// This will allow a DNS lookup periodically since HttpClient is static.
if (options == null)
{
options = new HttpRequestOptions();
}
using (var requestMessage = BuildRequestMessage(method, url, data, headers, options))
{
return(await SendRequestAsync(requestMessage, options.TimeoutInSeconds));
}
}
private Task <HttpResponseMessage> PostDataAsync(HttpMethodEnum method, string url, HttpContent content)
{
switch (method)
{
case HttpMethodEnum.POST:
return(httpClient.PostAsync(url, content));
case HttpMethodEnum.PUT:
return(httpClient.PutAsync(url, content));
case HttpMethodEnum.DELETE:
return(httpClient.DeleteAsync(url));
}
return(httpClient.PostAsync(url, content));
}
public static T ConfigureAndExecute <T>(APIContext apiContext, HttpMethodEnum httpMethod, string resource, string payload)
{
if (apiContext == null)
{
throw new Exception("APIContext object is null");
}
Dictionary <string, string> config = apiContext.Config;
string resourcePath = resource;
Dictionary <string, string> httpHeaders = apiContext.HTTPHeaders;
string requestId = apiContext.RequestId;
IAPICallPreHandler iApiCallPreHandler = Helper.CreateIAPICallPreHandler(config, httpHeaders, requestId, payload);
return(Helper.ConfigureAndExecute <T>(config, iApiCallPreHandler, httpMethod, resourcePath));
}
public async Task <string> HttpRequest(HttpClient client, string url, HttpMethodEnum httpMethod, string data = null, Dictionary <string, string> headers = null, string contentType = "application/json")
{
client ??= httpClient;
string result = string.Empty;
try
{
HttpResponseMessage response = null;
if (httpMethod == HttpMethodEnum.POST)
{
HttpContent content = new StringContent(data ?? "", Encoding.UTF8, contentType);
if (headers != null)
{
foreach (var h in headers)
{
content.Headers.Add(h.Key, h.Value);
}
}
response = await client.PostAsync(url, content);
}
else if (httpMethod == HttpMethodEnum.GET)
{
response = await client.GetAsync(url);
}
if (response != null && response.StatusCode == System.Net.HttpStatusCode.OK)
{
result = await response.Content.ReadAsStringAsync();
}
}
catch (Exception e)
{
var ex = e;
if (e.InnerException != null)
{
if (e.InnerException.InnerException != null)
{
ex = e.InnerException.InnerException;
}
else
{
ex = e.InnerException;
}
}
throw ex;
}
return(result);
}
public static string GetToken(HttpMethodEnum method, string url, HeaderCollection headers, string contentType, string body, string tokenPath, Guid tokenId, int tokenExpiresIn, bool cachedToken)
{
if (!string.IsNullOrEmpty(body) & string.IsNullOrEmpty(contentType))
{
throw new ArgumentNullException("ContentType cannot be null or empty when Body is specified", "contentType");
}
if (string.IsNullOrEmpty(tokenPath))
{
throw new ArgumentNullException("TokenPath cannot be null", "tokenPath");
}
string token = null;
if (cachedToken)
{
if (tokenExpiresIn <= 0)
{
throw new ArgumentException("tokenExpiresIn must have a value greater than zero.", "tokenExpiresIn");
}
if (tokenId == null || tokenId == Guid.Empty)
{
throw new ArgumentException("Invalid tokenId", "tokenId");
}
TokenInfo ti = AppDomainHelper.TokenDictionary.GetOrCreateTokenInfo(tokenId, tokenExpiresIn);
lock (ti)
{
if (ti.IsNew || !ti.IsValid | !cachedToken)
{
token = GetToken(method, url, headers, contentType, body, tokenPath);
ti.SetTokenInfo(token, DateTime.Now);
TokenDictionary.WriteLogMessage(message: $"Get new token for TokenId '{tokenId}'.", procName: "Cached Token");
}
else
{
token = ti.Token;
TokenDictionary.WriteLogMessage(message: $"Get token for TokenId '{tokenId}' from cache.", procName: "Cached Token");
}
}
}
else
{
token = GetToken(method, url, headers, contentType, body, tokenPath);
TokenDictionary.WriteLogMessage(message: $"Get new token", procName: "No Cache");
}
return(token);
}
/// <summary>
/// Http请求基础方法
/// </summary>
/// <param name="Url"></param>
/// <param name="HttpMethod"></param>
/// <param name="ContentType"></param>
/// <param name="data"></param>
/// <returns></returns>
private async Task<byte[]> HttpRequest(string Url, HttpMethodEnum HttpMethod, string ContentType, byte[] data)
{
byte[] result = null;
try
{
HttpResponseMessage message = null;
if (HttpMethod == HttpMethodEnum.POST)
{
using (Stream dataStream = new MemoryStream(data ?? new byte[0]))
{
using (HttpContent content = new StreamContent(dataStream))
{
content.Headers.Add("Content-Type", ContentType);
message = await _http.PostAsync(Url, content);
}
}
}
else if (HttpMethod == HttpMethodEnum.GET)
{
message =await _http.GetAsync(Url);
}
//处理返回的数据
using (message)
{
using (var responseStream = await message.Content.ReadAsStreamAsync())
{
if (responseStream != null)
{
byte[] responseData = new byte[responseStream.Length];
responseStream.Read(responseData, 0, responseData.Length);
result = responseData;
}
}
}
}
catch (Exception ex)
{
Log.Error(ex);
return new byte[0];
}
return result;
}
public SecurityTokenHelperBehavior(string authEndpoint, HttpMethodEnum method, HeaderCollection headers,
string contentType, string body, string tokenPath,
string tokenKey, string tokenPrefix, string tokenSuffix, TokenUsageEnum tokenUsage,
Guid tokenId, bool cacheToken, int tokenExpiresIn)
{
this.AuthEndpoint = authEndpoint;
this.HttpMethod = method;
this.Headers = headers;
this.TokenPath = tokenPath;
this.ContentType = contentType;
this.Body = body;
this.TokenKey = tokenKey;
this.TokenPrefix = tokenPrefix;
this.TokenSuffix = tokenSuffix;
this.TokenUsage = tokenUsage;
this.CacheToken = cacheToken;
this.TokenId = tokenId;
this.TokenExpiresIn = tokenExpiresIn;
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="domainName">Appsettings中配置的Domain key</param>
/// <param name="url">调用地址</param>
/// <param name="method">调用方式</param>
/// <param name="postdata">提交字段</param>
/// <param name="timeout">超时时间，单位秒</param>
/// <param name="proxy">代理地址</param>
/// <returns></returns>
public async Task <ApiResult <T> > CallAPI <T>(string url, HttpMethodEnum method, IDictionary <string, string> postdata, int?timeout = null, string proxy = null) where T : class
{
HttpContent content = null;
//填充表单数据
if (!(postdata == null || postdata.Count == 0))
{
List <KeyValuePair <string, string> > paras = new List <KeyValuePair <string, string> >();
foreach (string key in postdata.Keys)
{
paras.Add(new KeyValuePair <string, string>(key, postdata[key]));
}
if (paras.Any())
{
url = url.AppendQuery(paras);
}
content = new FormUrlEncodedContent(paras);
}
return(await CallAPI <T>(url, method, content, timeout, proxy));
}
public async Task <ApiResult <T> > CallAPI <T>(string url, HttpMethodEnum method, IDictionary <string, string> postdata, byte[] filedata, string filename, int?timeout = null, string proxy = null) where T : class
{
MultipartFormDataContent content = new MultipartFormDataContent();
//填充表单数据
if (!(postdata == null || postdata.Count == 0))
{
List <KeyValuePair <string, string> > paras = new List <KeyValuePair <string, string> >();
foreach (string key in postdata.Keys)
{
if (postdata[key] != null)
{
content.Add(new StringContent(postdata[key]), key);
}
}
}
content.Add(new ByteArrayContent(filedata), "File", filename);
return(await CallAPI <T>(url, method, content, timeout, proxy));
}
async Task <TOutput> CallWebApiAsync <TInput, TOutput>(TInput input,
string endpoint,
HttpMethodEnum method,
CancellationToken cancellationToken) where TInput : class
{
return(await Task.Run(async() =>
{
HttpContent content = null;
if (input != null)
{
content = await SerializeContent <TInput>(input, endpoint);
}
var startupUri = new Uri(endpoint);
HttpResponseMessage response = null;
switch (method)
{
case HttpMethodEnum.Get:
response = await _client.GetAsync(endpoint, cancellationToken);
break;
case HttpMethodEnum.Post:
response = await _client.PostAsync(endpoint, content, cancellationToken);
break;
case HttpMethodEnum.Put:
response = await _client.PutAsync(endpoint, content, cancellationToken);
break;
case HttpMethodEnum.Delete:
response = await _client.DeleteAsync(endpoint, cancellationToken);
break;
default:
break;
}
return await ManageBackendResponse <TOutput>(endpoint, response);
}, cancellationToken));
}
async Task <TOutput> CallWebApiAsync <TOutput>(string endpoint, HttpMethodEnum method, CancellationToken cancellationToken)
{
return(await Task.Run(async() =>
{
HttpContent content = null;
#if DEBUG
System.Diagnostics.Debug.WriteLine($"{endpoint} Request {method}");
#endif
var startupUri = new Uri(endpoint);
HttpResponseMessage response = null;
switch (method)
{
case HttpMethodEnum.Get:
response = await _client.GetAsync(endpoint, cancellationToken);
break;
case HttpMethodEnum.Post:
response = await _client.PostAsync(endpoint, content, cancellationToken);
break;
case HttpMethodEnum.Put:
response = await _client.PutAsync(endpoint, content, cancellationToken);
break;
case HttpMethodEnum.Delete:
response = await _client.DeleteAsync(endpoint, cancellationToken);
break;
default:
break;
}
return await ManageBackendResponse <TOutput>(endpoint, response);
}, cancellationToken));
}
