/// <summary>
/// HttpClient请求 采用SendAsync方法
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="requestUri">请求地址</param>
/// <param name="content">发送数据</param>
/// <param name="httpMethod">请求方式</param>
/// <returns></returns>
public ResponseResult <T> HttpClientRequest <T>(string requestUri, object content, string httpMethod,
WebHeaderCollection webHeaders = null,
ResponseResultType resultType = ResponseResultType.ResultInfo)
{
try
{
//设置全局定义的个性化安全认证
SetDefaultHeaders(_httpItem.SecurityHeaders);
//加载或者更新私定的安全认证
SetDefaultHeaders(webHeaders);
var method = new HttpMethod(httpMethod);
var postData = JsonConvert.SerializeObject(content);
var httpContent = new StringContent(postData, Encoding.UTF8);
var request = new HttpRequestMessage(method, requestUri)
{
Content = httpContent
};
var responseResult = _client.SendAsync(request);
//处理数据解析
return(JsonConvertResultData <T>(responseResult, resultType));
}
catch (InvalidOperationException ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.Message
});
}
}
/// <summary>
/// Http Get方式请求/查询数据
/// </summary>
/// <param name="url">接口地址</param>
/// <param name="webHeaders">HttpHeader 可增加一些验证信息</param>
/// <param name="resultType">返回结果的类型</param>
/// <returns></returns>
public ResponseResult <T> HttpGet <T>(string url, WebHeaderCollection webHeaders = null,
ResponseResultType resultType = ResponseResultType.ResultInfo)
{
try
{
//设置全局定义的个性化安全认证
SetDefaultHeaders(_httpItem.SecurityHeaders);
//加载或者更新私定的安全认证
SetDefaultHeaders(webHeaders);
var GetResult = _client.GetAsync(url);
//处理数据解析
return(JsonConvertResultData <T>(GetResult, resultType));
}
catch (InvalidOperationException ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
catch (Exception ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
}
/// <summary>
/// Http DELETE请求方式 删除数据
/// </summary>
/// <param name="url"></param>
/// <param name="content"></param>
/// <returns></returns>
public ResponseResult <T> HttpDelete <T>(string url, WebHeaderCollection webHeaders = null,
ResponseResultType resultType = ResponseResultType.ResultInfo)
{
try
{
//设置全局定义的个性化安全认证
SetDefaultHeaders(_httpItem.SecurityHeaders);
//加载或者更新私定的安全认证
SetDefaultHeaders(webHeaders);
//var postDate = JsonConvert.SerializeObject("");
//var httpContent = new StringContent(postDate, Encoding.UTF8);
//httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json") { CharSet = "utf-8" };
var postResult = _client.DeleteAsync(url);
//处理数据解析
return(JsonConvertResultData <T>(postResult, resultType));
}
catch (InvalidOperationException ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
catch (Exception ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.StackTrace
});
}
}
private ResponseResult(ResponseResultType resultType, IResponse response = null)
{
_resultType = resultType;
_response = response;
}
private ResponseResult(ResponseResultType resultType, Task<IResponse> response = null, string cacheKey = null)
{
_resultType = resultType;
_response = response;
_cacheKey = cacheKey;
}
private static Task <HttpResponseItem> GetHttpResponseItem(HttpResponseMessage response, ResponseResultType resultType)
{
var responseItem = new HttpResponseItem
{
ResultType = resultType,
Location = response.Headers.Location,
StatusCode = response.StatusCode
};
switch (resultType)
{
case ResponseResultType.String:
{
var r = response.Content.ReadAsStringAsync();
r.Wait();
responseItem.ResponseString = r.Result; // await response.Content.ReadAsStringAsync().ConfigureAwait(false);
break;
}
case ResponseResultType.Byte:
{
var r = response.Content.ReadAsByteArrayAsync();
r.Wait();
responseItem.ResponseBytes = r.Result; // await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
break;
}
case ResponseResultType.Stream:
{
var r = response.Content.ReadAsByteArrayAsync();
r.Wait();
responseItem.ResponseStream = new MemoryStream(r.Result); //await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false)
break;
}
}
foreach (var header in response.Headers)
{
responseItem.Headers[header.Key] = header.Value.ToList();
}
foreach (var header in response.Content.Headers)
{
responseItem.Headers[header.Key] = header.Value.ToList();
}
return(Task.Factory.StartNew(() => { return responseItem; }));
//return responseItem;
}
/// <summary>
/// 解析Task<HttpResponseMessage>对象
/// 返回的结果类型ResponseResult
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="httpResponse"></param>
/// <returns>ResponseResult<T></returns>
private ResponseResult <T> JsonConvertResultData <T>(Task <HttpResponseMessage> httpResponse, ResponseResultType resultType)
{
try
{
httpResponse.Result.EnsureSuccessStatusCode();
HttpResponseMessage response = httpResponse.Result;
if (response.IsSuccessStatusCode)
{
//请求成功 200
//将HTTP 内容序列化到字符串以作为异步操作
var Readresult = response.Content.ReadAsStringAsync();
//没有任何返回内容
if (string.IsNullOrEmpty(Readresult.Result))
{
return(new ResponseResult <T>()
{
Code = 0, Msg = "没有返回内容!"
});
}
else
{
try
{
if (resultType == ResponseResultType.ResultInfo)
{
var ResultList = JsonConvert.DeserializeObject <ResponseResult <T> >(Readresult.Result);
return(ResultList);
}
else
{
var Result = JsonConvert.DeserializeObject <T>(Readresult.Result);
return(new ResponseResult <T>()
{
Code = 0,
Msg = "",
Data = Result
});
}
}
catch (Exception ex)
{
return(new ResponseResult <T>()
{
Code = 0, Msg = Readresult.Result
});
}
}
}
else
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = "HttpCode：" + response.StatusCode.ToString()
});
}
}
catch (HttpRequestException hre)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = hre.Message
});
}
catch (Exception ex)
{
return(new ResponseResult <T>()
{
Code = (int)HttpStatusCode.BadRequest, Msg = ex.Message
});
}
}
private ResponseResult(ResponseResultType resultType, Task <IResponse> response, string cacheKey)
{
_resultType = resultType;
_response = response;
_cacheKey = cacheKey;
}
public DetailDataListUseCaseResponse(ResponseResultType resultType, string cause, IEnumerable <UserDetail> userDetails) : base(resultType, cause)
{
_userDetails = userDetails != null ? new List <UserDetail>(userDetails) : Enumerable.Empty <UserDetail>().ToList();
}
private ResponseResult(ResponseResultType resultType, IResponse response)
{
_resultType = resultType;
_response = response;
}
private ResponseResult(ResponseResultType resultType, IResponse response, string cacheKey)
{
_resultType = resultType;
_response = response;
_cacheKey = cacheKey;
}
private static async Task<HttpResponseItem> GetHttpResponseItem(HttpResponseMessage response, ResponseResultType resultType)
{
var responseItem = new HttpResponseItem
{
ResultType = resultType,
Location = response.Headers.Location,
StatusCode = response.StatusCode
};
switch (resultType)
{
case ResponseResultType.String:
{
responseItem.ResponseString = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
break;
}
case ResponseResultType.Byte:
{
responseItem.ResponseBytes = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
break;
}
case ResponseResultType.Stream:
{
responseItem.ResponseStream = new MemoryStream(await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false));
break;
}
}
foreach (var header in response.Headers)
{
responseItem.Headers[header.Key] = header.Value.ToList();
}
foreach (var header in response.Content.Headers)
{
responseItem.Headers[header.Key] = header.Value.ToList();
}
return responseItem;
}
protected ResponseBase(ResponseResultType resultType, string cause)
{
ResultType = resultType;
Cause = cause;
}
public GetCurrentDateTimeUseCaseResponse(ResponseResultType resultType, string cause, DateTime currentTime) :
base(resultType, cause)
{
CurrentTime = currentTime;
}
