/// <summary>
/// 异步Get请求
/// </summary>
/// <param name="url"></param>
/// <param name="callBack"></param>
/// <param name="timeout"></param>
/// <returns></returns>
public static async Task GetAsync(string url, HttpResponseHandler callBack = null,
double?timeout = null)
{
url = NetHelper.FormatRequestUrl(url);
HttpResponse responseMsg = null;
// 单机测试，使用FakeData生成随机测试数据模拟网络访问
if (AppRunConfigs.Instance.IsSingleTestMode)
{
var genTypes = callBack.Method.GetGenericArguments();
SAssert.MustTrue(genTypes.Length == 1, string.Format("非法的泛型回调在PostAsync {0}", genTypes));
callBack?.Invoke(ClientFakeDataHelper.Instance.CreateFakeDataNetResponse(genTypes[0]), null);
return;
}
SLogger.Info($"Start Get AsyncRequest\nUrl:{url}\n");
try
{
//SetNetDALTimeout(timeout);
var httpResponse = await s_asyncWebClient.GetAsync(url, HttpCompletionOption.ResponseContentRead);
string responseContent = null;
if (httpResponse.IsSuccessStatusCode)
{
var resultStr = await httpResponse.Content.ReadAsStringAsync();
responseContent = resultStr;
}
responseMsg = new HttpResponse(responseContent, httpResponse.StatusCode);
}
catch (HttpRequestException ex)
{
//responseMsg = new HttpResponse(ex.ToString(), HttpStatusCode.ExpectationFailed);
responseMsg = new HttpResponse("网络请求异常", HttpStatusCode.ExpectationFailed);
responseMsg.ResponseMsg = ex.ToString();
}
catch (Exception ex)
{
//responseMsg = new HttpResponse(ex.ToString(), HttpStatusCode.ExpectationFailed);
responseMsg = new HttpResponse("系统异常", HttpStatusCode.ExpectationFailed);
responseMsg.ResponseMsg = ex.ToString();
}
finally
{
callBack?.Invoke(responseMsg, null);
}
}
public async Task HttpGetStreamInvokeAsync(string url, IEnumerable <Header> headers, TimeSpan timeOut, HttpResponseHandler httpResponseHandler)
{
using (var httpClient = new HttpClient())
{
headers.ToList().ForEach(h => { httpClient.DefaultRequestHeaders.Add(h.Key, h.Value); });
HttpResponseMessage httpResponse = await httpClient.GetAsync(url);
string respBody = await httpResponse.Content.ReadAsStringAsync();
List <Header> responseHeaders = new List <Header>();
responseHeaders.AddRange(
httpResponse.Headers.Select(c =>
{
return(Header.CreateHeader(c.Key, c.Value));
}));
List <Header> responseContentHeaders = new List <Header>();
responseContentHeaders.AddRange(
httpResponse.Content.Headers.Select(c =>
{
return(Header.CreateHeader(c.Key, c.Value));
}));
httpResponseHandler?.Invoke(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(httpResponse.StatusCode,
httpResponse.ReasonPhrase, responseHeaders, responseContentHeaders, String.Empty, true)));
}
}
public async Task HttpPostInvoke(string url, IEnumerable <Header> headers, IEnumerable <Header> contentHeader,
Dictionary <string, string> postParameters, TimeSpan timeOut,
HttpResponseHandler httpResponseHandler)
{
// Build the form data (exclude OAuth stuff that's already in the
// header).
var formData = new FormUrlEncodedContent(postParameters);
contentHeader.ToList().ForEach(h => { formData.Headers.Add(h.Key, h.Value); });
using (var httpClient = new HttpClient())
{
headers.ToList().ForEach(h => { httpClient.DefaultRequestHeaders.Add(h.Key, h.Value); });
HttpResponseMessage httpResponse = await httpClient.PostAsync(url, formData);
string respBody = await httpResponse.Content.ReadAsStringAsync();
List <Header> responseHeaders = new List <Header>();
responseHeaders.AddRange(
httpResponse.Headers.Select(c =>
{
return(Header.CreateHeader(c.Key, c.Value));
}));
List <Header> responseContentHeaders = new List <Header>();
responseContentHeaders.AddRange(
httpResponse.Content.Headers.Select(c =>
{
return(Header.CreateHeader(c.Key, c.Value));
}));
httpResponseHandler?.Invoke(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(httpResponse.StatusCode,
httpResponse.ReasonPhrase, responseHeaders, responseContentHeaders, String.Empty, true)));
}
}
/// <summary>
/// 异步POST请求
/// TOFIX:待添加超时逻辑
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="url"></param>
/// <param name="param"></param>
/// <param name="callBack"></param>
/// <param name="timeout"></param>
public static async Task PostAsync <T>(string url, T param = null,
HttpResponseHandler callBack = null, double?timeout = null)
where T : class, new()
{
// 单机测试，使用FakeData生成随机测试数据模拟网络访问
if (AppRunConfigs.Instance.IsSingleTestMode)
{
var genTypes = callBack.Method.GetGenericArguments();
SAssert.MustTrue(genTypes.Length == 1, string.Format("非法的泛型回调在PostAsync {0}", genTypes));
var genType = genTypes[0];
var genNum = -1;
if (genType.IsAssignableFrom(typeof(BaseOpResult)))
{
genNum = 1;
}
// 生成随机等待时间，模拟网络请求耗时
var randomGenDataCostTime = FakeDataHelper.Instance.GenRandomInt(AppRunConfigs.Instance.DefaultRequestTimeout);
// 模拟1/2的请求是要等待长时间，而另外1/2的请求等待短时间
if (randomGenDataCostTime <= AppRunConfigs.Instance.DefaultRequestTimeout / 2)
{
randomGenDataCostTime = 300;
}
await Task.Delay(randomGenDataCostTime);
// FIXME：目前超时情况下，没有关掉该网络请求，会导致提示了网路请求超时错误之后，仍然会返回数据结果（正确应该中断这次请求！）
callBack?.Invoke(ClientFakeDataHelper.Instance.CreateFakeDataNetResponse(genType, genNum), null);
return;
}
HttpContent requestContent = null;
if (null != param)
{
var strJson = JsonHelper.SerializeTo(param);
requestContent = new StringContent(strJson);
requestContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
}
await PostContentAsync(url, requestContent, callBack, timeout);
}
private static IEnumerator CreateCoroutine(string method, string url, Dictionary <string, string> headers, byte[] body, HttpResponseHandler handler)
{
var request = new UnityWebRequest(url, method);
if (headers != null)
{
foreach (var item in headers)
{
request.SetRequestHeader(item.Key, item.Value);
}
}
if (body != null)
{
request.uploadHandler = new UploadHandlerRaw(body);
}
request.downloadHandler = new DownloadHandlerBuffer();
yield return(request.SendWebRequest());
handler?.Invoke((int)request.responseCode, request.downloadHandler.text, request.downloadHandler.data);
}
private async Task HttpStreamInvokeAsync(string url, HttpMethod httpMethod, IEnumerable <Header> headers,
IEnumerable <Header> contentHeaders, HttpInvocationCompletionOption httpInvocationCompletetionOption,
string postParameters, TimeSpan timeOut, HttpResponseHandler httpResponseHandler,
CancellationToken cancellationToken)
{
postParameters = postParameters ?? String.Empty;
byte[] bufferPostParameters = Encoding.UTF8.GetBytes(postParameters);
using (StreamContent streamContent = new StreamContent(new MemoryStream(bufferPostParameters)))
{
if (httpMethod == HttpMethod.Post)
{
contentHeaders.ToList().ForEach(h => { streamContent.Headers.Add(h.Key, h.Value); });
}
using (HttpClient httpClient = new HttpClient())
{
httpClient.Timeout = timeOut;
headers.ToList().ForEach(h => { httpClient.DefaultRequestHeaders.Add(h.Key, h.Value); });
httpClient.BaseAddress = new Uri(url);
var request = new HttpRequestMessage(httpMethod, url);
if (httpMethod == HttpMethod.Post)
{
request.Content = streamContent;
}
if (cancellationToken.IsCancellationRequested)
{
return;
}
await httpClient.SendAsync(request, (HttpCompletionOption)httpInvocationCompletetionOption)
.ContinueWith(async responseTask =>
{
using (HttpResponseMessage response = responseTask.Result)
{
await response.Content.ReadAsStreamAsync().ContinueWith(streamTask =>
{
using (StreamReader streamReader = new StreamReader(streamTask.Result))
{
List <Header> responseHeaders = new List <Header>();
responseHeaders.AddRange(
response.Headers.Select(c => { return(Header.CreateHeader(c.Key, c.Value)); }));
List <Header> responseContentHeaders = new List <Header>();
responseContentHeaders.AddRange(
response.Content.Headers.Select(c => { return(Header.CreateHeader(c.Key, c.Value)); }));
try
{
while (!streamReader.EndOfStream && !cancellationToken.IsCancellationRequested)
{
if (httpResponseHandler != null)
{
string json = streamReader.ReadLine();
httpResponseHandler(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(response.StatusCode,
response.ReasonPhrase, headers, contentHeaders, json, false)));
}
}
}
catch (Exception ex)
{
Exception e = ex;
}
finally
{
if (!cancellationToken.IsCancellationRequested)
{
httpResponseHandler?.Invoke(this,
new HttpInvokerResponseArgs(new HttpInvokerResponse(response.StatusCode,
response.ReasonPhrase, headers, contentHeaders, String.Empty, true)));
}
}
}
});
}
});
}
}
}
/// <summary>
/// 异步POST请求
/// TOFIX:待添加超时逻辑
/// </summary>
/// <param name="url"></param>
/// <param name="content"></param>
/// <param name="callBack"></param>
/// <param name="timeout"></param>
public static async Task PostContentAsync(string url, HttpContent content,
HttpResponseHandler callBack, double?timeout = null)
{
url = NetHelper.FormatRequestUrl(url);
HttpResponse responseMsg = null;
var requestDTO = new WebReqResStatisticsDTO()
{
RequestFullUrl = url,
Method = "POST",
InTime = DateTime.Now,
RequestBody = content?.ToString(),
};
try
{
//SetNetDALTimeout(timeout);
if (null == callBack)
{
// 无回调请求，可以优化成发送之后就不管了
await s_asyncWebClient.PostAsync(url, content);
return;
}
var httpResponse = await s_asyncWebClient.PostAsync(url, content);
string responseContent = null;
if (httpResponse.IsSuccessStatusCode)
{
string resultStr = await httpResponse.Content.ReadAsStringAsync();
responseContent = resultStr;
}
requestDTO.ResponseBody = responseContent;
requestDTO.OutTime = DateTime.Now;
requestDTO.Cost = (long)(requestDTO.OutTime - requestDTO.InTime).TotalMilliseconds;
responseMsg = new HttpResponse(responseContent, httpResponse.StatusCode);
}
catch (HttpRequestException ex)
{
//responseMsg = new HttpResponse(ex.ToString(), HttpStatusCode.ExpectationFailed);
responseMsg = new HttpResponse("网络请求异常", HttpStatusCode.ExpectationFailed);
responseMsg.ResponseMsg = ex.ToString();
}
catch (Exception ex)
{
//responseMsg = new HttpResponse(ex.ToString(), HttpStatusCode.ExpectationFailed);
responseMsg = new HttpResponse("系统异常", HttpStatusCode.ExpectationFailed);
responseMsg.ResponseMsg = ex.ToString();
}
finally
{
SLogger.Debug(JsonHelper.SerializeTo(requestDTO));
callBack?.Invoke(responseMsg, null);
}
}
