public async Task <Result <WeatherForecast> > DeleteDemo()
{
var url = UrlArguments.Create("msgpack", "WeatherForecast/DeleteWeather");
var res = await _httpService.DeleteAsync <Result <WeatherForecast> >(url, HttpMediaType.MessagePack);
return(Success("0000001", "POST成功", res.data));
}
public async Task <Result <List <WeatherForecast> > > GetDemo()
{
var url = UrlArguments.Create("msgpack", "WeatherForecast/GetWeather");
var res = await _httpService.GetAsync <Result <List <WeatherForecast> > >(url, HttpMediaType.MessagePack);
return(Success("0000001", "查询成功", res.data));
}
//[NoCache]
//[Route("{id}")]
//[RazorHtmlStatic(Template = "/static/{controller}/{action}-{id}.html")]
//public async Task<IActionResult> Index(int id, CancellationToken cancellationToken)
//{
//var url = UrlArguments.Create("test", $"/api/CommentsLive/GetPaged")
// .Add("aid", 1539)
// .Add("commentId", 0)
// .Add("pageSize", 10000);
//var res = await _httpService.GetAsync<ReturnModel>(url, cancellationToken);
// return View(res);
//}
public async Task <IActionResult> IndexView()
{
var url = UrlArguments.Create("test", $"/api/CommentsLive/GetPaged")
.Add("aid", 1539)
.Add("commentId", 0)
.Add("pageSize", 10000);
var res = await _httpService.GetAsync <ReturnModel>(url);
return(View(res));
}
public async Task <Result <WeatherForecast> > PutDemo()
{
var url = UrlArguments.Create("msgpack", "WeatherForecast/PutWeather");
WeatherForecast weather = new WeatherForecast
{
Date = DateTime.UtcNow,
Summary = "测试POST",
TemperatureC = 33
};
var res = await _httpService.PutAsync <Result <WeatherForecast>, WeatherForecast>(url, weather, HttpMediaType.MessagePack);
return(Success("0000001", "POST成功", res.data));
}
/// <summary>
/// 异步POST请求
/// </summary>
/// <typeparam name="TModel">提交类型</typeparam>
/// <typeparam name="TResult">返回类型</typeparam>
/// <param name="httpMessageService"><see cref="IHttpMessageService"/>操作服务</param>
/// <param name="urlArguments"><see cref="UrlArguments"/>Url构造器</param>
/// <param name="model">提交的模型数据</param>
/// <param name="mediaType">请求返回的数据类型<see cref="HttpMediaType"/></param>
/// <param name="options">序列化方式<see cref="MessagePackSerializerResolver"/>，如果是JSON不需要设置</param>
/// <param name="clientHandler"><see cref="HttpClient"/>回调，可以添加需要的Header等</param>
/// <param name="errorHandler"><see cref="HttpResponseMessage"/>请求异常处理，默认情况返回错误的Return模型</param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public static async Task <TResult> PostAsync <TModel, TResult>(this IHttpMessageService httpMessageService, UrlArguments urlArguments, TModel model,
HttpMediaType mediaType = HttpMediaType.Json, MessagePackSerializerOptions options = null, Action <HttpClient> clientHandler = null, Func <HttpResponseMessage, TResult> errorHandler = null, CancellationToken cancellationToken = default)
{
options = options ?? MessagePackSerializerResolver.DateTimeOptions;
var client = httpMessageService.CreateClient(urlArguments.ClientName)
.SetHeaderAccept(mediaType);
if (clientHandler != null)
{
clientHandler.Invoke(client);
}
var responseMessage = await client.PostAsync(urlArguments, model, cancellationToken);
if (!responseMessage.IsSuccessStatusCode)
{
return(errorHandler == null ? default : errorHandler.Invoke(responseMessage));
}
else
{
return(await responseMessage.Content.ReadAsAsync <TResult>(mediaType, options));
}
}
public static async Task <HttpResponseMessage> DeleteAsync(this HttpClient httpClient, UrlArguments urlArguments, CancellationToken cancellationToken = default)
{
string requestUrl = urlArguments.Complete().Url;
return(await httpClient.DeleteAsync(requestUrl, cancellationToken));
}
public static async Task <HttpResponseMessage> PatchAsync <TModel>(this HttpClient httpClient, UrlArguments urlArguments, TModel model, CancellationToken cancellationToken = default)
{
var content = HttpContentMessage.CreateJsonContent(model, Encoding.UTF8);
return(await httpClient.PatchAsync(urlArguments, content, cancellationToken));
}
public async Task <ReturnModel> Broadcast([FromBody] BroadcastMessage message)
{
var url = UrlArguments.Create("http://127.0.0.1:8080/api/Broadcast/Push");
return(await _httpService.PostAsync <ReturnModel, BroadcastMessage>(url, message));
}
public async Task <IActionResult> Index(CancellationToken cancellationToken)
{
var list = new List <AdminUsers>();
for (var ndx = 0; ndx < 10; ndx++)
{
var user = new AdminUsers
{
Company = "test",
CreatedTime = DateTime.Now,
Location = "test",
LoginCount = 0,
LoginLastIp = "127.0.0.1",
LoginLastTime = DateTime.Now,
Mobile = "17710146178",
Name = $"徐毅{ndx}",
Password = "******",
Picture = $"徐毅{ndx}",
Position = $"徐毅{ ndx }",
Status = true,
UserName = "******"
};
list.Add(user);
}
var res0 = _dbAdminUsersServiceProvider.Insert(list.ToArray());
var re2 = await _dbAdminUsersServiceProvider.BatchUpdateAsync(c => c.Id > 22, c => new AdminUsers()
{
Name = "哈德斯", Location = "吹牛逼总监", Company = "大牛逼公司"
});
var re1 = await _dbAdminUsersServiceProvider.BatchDeleteAsync(c => c.Id > 22);
var ur2 = UrlArguments.Create("api/messagepack/add");
var resData = await _httpMessage.CreateClient("msgtest").SetHeaderAccept(HttpMediaType.MessagePack).PostAsync <User>(ur2, null, cancellationToken);
if (resData.IsSuccessStatusCode)
{
}
var m = await resData.Content.ReadAsAsync <User>(HttpMediaType.MessagePack);
var url = UrlArguments.Create("msgpack", "api/messagepack/get");
var res = await _httpService.GetAsync <User>(url, cancellationToken);
var postUrl = UrlArguments.Create("msgpack", "api/messagepack/add");
var res1 = await _httpService.PostAsync <User, User>(postUrl, res, cancellationToken);
var url1 = UrlArguments.Create("test", $"/api/CommentsLive/GetPaged")
.Add("aid", 1539)
.Add("commentId", 0)
.Add("pageSize", 10000);
var res2 = await _httpService.GetAsync <ReturnModel>(url1, cancellationToken);
return(View(res2));
}
/// <summary>
/// PUT提交数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TModel"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="postData">模型数据</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public async Task <T> PutAsync <T, TModel>(UrlArguments urlArguments, TModel postData, CancellationToken cancellationToken = default)
where T : class, new()
=> await HttpSendAsync <T, TModel>(urlArguments, HttpMethod.Put, postData, HttpMediaType.Json, cancellationToken);
/// <summary>
/// GET请求数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="mediaType">mediaType数据格式，请求格式和返回格式一致（JSON、MessagePack）</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public async Task <T> GetAsync <T>(UrlArguments urlArguments, HttpMediaType mediaType, CancellationToken cancellationToken = default)
where T : class, new()
=> await HttpSendAsync <T>(urlArguments, HttpMethod.Get, null, mediaType, cancellationToken);
/// <summary>
/// 发送请求数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="method">请求类型</param>
/// <param name="contentCall">HttpContent请求内容</param>
/// <param name="mediaType">mediaType数据格式，请求格式和返回格式一致（JSON、MessagePack）</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public virtual async Task <T> HttpSendAsync <T>(UrlArguments urlArguments, HttpMethod method, Func <HttpContent> contentCall, HttpMediaType mediaType = HttpMediaType.Json, CancellationToken cancellationToken = default)
where T : class, new()
{
HttpClient client = HttpClientFactory.CreateClient(string.IsNullOrEmpty(urlArguments.ClientName) ? "apiClient" : urlArguments.ClientName);
string requestUrl = urlArguments.Complete().Url;
string _mediaType = mediaType.Description();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(_mediaType));
HttpResponseMessage responseMessage = null;
if (client.BaseAddress == null)
{
HttpRequestMessage requestMessage = new HttpRequestMessage
{
Method = method,
RequestUri = new Uri(requestUrl)
};
foreach (var accept in client.DefaultRequestHeaders.Accept)
{
requestMessage.Headers.Accept.Add(accept);
}
requestMessage.Headers.Authorization = client.DefaultRequestHeaders.Authorization;
RequestHeaders(requestMessage.Headers);
requestMessage.Content = contentCall?.Invoke();
//if (requestMessage.Content != null)
// requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);
responseMessage = await client.SendAsync(requestMessage, cancellationToken);
}
else
{
RequestHeaders(client.DefaultRequestHeaders);
HttpContent content = contentCall?.Invoke();
//if (content != null)
// content.Headers.ContentType = new MediaTypeHeaderValue(_mediaType);
responseMessage = await SendAsync(client, requestUrl, method, content, cancellationToken);
}
switch (mediaType)
{
case HttpMediaType.MessagePack:
{
var res = await responseMessage.Content.ReadAsByteArrayAsync();
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Byte Data Length：{res.Length}");
}
return(res.ToMsgPackObject <T>());
}
case HttpMediaType.MessagePackJackson:
{
var res = await responseMessage.Content.ReadAsStringAsync();
if (_logger.IsEnabled(LogLevel.Debug))
{
_logger.LogDebug($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Jackson Data：{res}");
}
return(res.ToMsgPackBytesFromJson().ToMsgPackObject <T>());
}
default:
{
var res = await responseMessage.Content.ReadAsStringAsync();
if (_logger.IsEnabled(LogLevel.Information))
{
_logger.LogInformation($"{client.BaseAddress}{requestUrl} MediaType：{_mediaType}，Method：{method.Method}，HttpMessage Read Json Data：{res}");
}
return(res.ToObject <T>());
}
}
}
/// <summary>
/// 发送请求数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TModel"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="method">请求类型</param>
/// <param name="postData">模型数据</param>
/// <param name="mediaType">mediaType数据格式，请求格式和返回格式一致（JSON、MessagePack）</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public async Task <T> HttpSendAsync <T, TModel>(UrlArguments urlArguments, HttpMethod method, TModel postData, HttpMediaType mediaType = HttpMediaType.Json, CancellationToken cancellationToken = default)
where T : class, new()
=> await HttpSendAsync <T>(urlArguments, method, () => postData == null?null : new StringContent(postData.ToJson(), Encoding.UTF8, "application/json"), mediaType, cancellationToken);
/// <summary>
/// DELETE请求删除数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="urlArguments">Url构造器</param>
/// <param name="cancellationToken">取消令牌</param>
/// <returns></returns>
public async Task <T> DeleteAsync <T>(UrlArguments urlArguments, CancellationToken cancellationToken = default)
where T : class, new()
=> await HttpSendAsync <T>(urlArguments, HttpMethod.Delete, null, HttpMediaType.Json, cancellationToken);
