/// <summary>
/// 获取异步结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task <object> GetTaskResult(ApiActionContext context)
{
var response = context.ResponseMessage.EnsureSuccessStatusCode();
var json = await response.Content.ReadAsStringAsync();
var dataType = context.ApiActionDescriptor.ReturnDataType;
var result = context.HttpApiClient.JsonFormatter.Deserialize(json, dataType);
return(result);
}
/// <summary>
/// 执行api
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public object Execute(ApiActionContext context)
{
if (ReturnTaskType.IsGenericType && ReturnTaskType.GetGenericTypeDefinition() == typeof(Task <>))
{
return(this.ExecuteAsync(context).CastResult(this.ReturnDataType));
}
else
{
return(((dynamic)this.ExecuteAsync(context).CastResult(this.ReturnDataType)).Result);
}
}
/// <summary>
/// 获取http请求内容
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
protected override HttpContent GetHttpContent(ApiActionContext context, ApiParameterDescriptor parameter)
{
var xmlSerializer = new XmlSerializer(parameter.ParameterType);
using (var stream = new MemoryStream())
{
xmlSerializer.Serialize(stream, parameter.Value);
var xml = Encoding.UTF8.GetString(stream.ToArray());
return(new StringContent(xml, Encoding.UTF8, "application/xml"));
}
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public sealed override async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
if (context.RequestMessage.Method == HttpMethod.Get)
{
return;
}
var httpContent = this.GetHttpContent(context, parameter);
context.RequestMessage.Content = httpContent;
await TaskExtensions.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public override async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
if (this.IgnoreWhenNull && parameter.Value == null)
{
return;
}
var uri = context.RequestMessage.RequestUri;
var baseUrl = uri.Scheme + "://" + uri.Host + (uri.IsDefaultPort ? "" : ":" + uri.Port);
var pathQuery = GetPathQuery(uri.LocalPath.Trim('/'), parameter);
context.RequestMessage.RequestUri = new Uri(new Uri(baseUrl), pathQuery);
await TaskExtensions.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public override async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
if (this.IgnoreWhenNull && parameter.Value == null)
{
return;
}
var uri = context.RequestMessage.RequestUri;
var pathQuery = this.GetPathQuery(uri.LocalPath + uri.Query, parameter);
context.RequestMessage.RequestUri = new Uri(uri, pathQuery);
await TaskExtensions.CompletedTask;
}
/// <summary>
/// 获取异步结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task <object> GetTaskResult(ApiActionContext context)
{
var response = context.ResponseMessage;
var dataType = context.ApiActionDescriptor.ReturnDataType;
var xmlSerializer = new XmlSerializer(dataType);
using (var stream = new MemoryStream())
{
await response.Content.CopyToAsync(stream);
stream.Position = 0;
return(xmlSerializer.Deserialize(stream));
}
}
/// <summary>
/// 异步执行api
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
private async Task <object> ExecuteAsync(ApiActionContext context)
{
foreach (var methodAttribute in context.ApiActionDescriptor.Attributes)
{
await methodAttribute.BeforeRequestAsync(context);
}
foreach (var parameter in context.ApiActionDescriptor.Parameters)
{
foreach (var parameterAttribute in parameter.Attributes)
{
await parameterAttribute.BeforeRequestAsync(context, parameter);
}
}
foreach (var filter in context.ApiActionFilterAttributes)
{
await filter.OnBeginRequestAsync(context);
}
var httpClient = context.HttpApiClient.HttpClient;
context.ResponseMessage = await httpClient.SendAsync(context.RequestMessage);
foreach (var filter in context.ApiActionFilterAttributes)
{
await filter.OnEndRequestAsync(context);
}
if (context.ApiReturnAttribute != null)
{
return(await context.ApiReturnAttribute.GetTaskResult(context));
}
foreach (var attr in Assembly.GetExecutingAssembly().GetTypes()
.Where(x => x.BaseType == typeof(ApiReturnAttribute)).Select(x => Activator.CreateInstance(x) as ApiReturnAttribute))
{
var result = await attr.GetTaskResult(context);
if (result != null)
{
return(result);
}
}
var message = string.Format("不支持的类型{0}的解析", context.ApiActionDescriptor.ReturnDataType);
throw new NotSupportedException(message);
}
/// <summary>
/// 方法拦截
/// </summary>
/// <param name="invocation">拦截内容</param>
void IInterceptor.Intercept(IInvocation invocation)
{
var context = CastleContext.From(invocation);
var actionContext = new ApiActionContext
{
HttpApiClient = this,
RequestMessage = new HttpRequestMessage(),
HostAttribute = context.HostAttribute,
ApiReturnAttribute = context.ApiReturnAttribute,
ApiActionFilterAttributes = context.ApiActionFilterAttributes,
ApiActionDescriptor = context.ApiActionDescriptor.Clone() as ApiActionDescriptor
};
var parameters = actionContext.ApiActionDescriptor.Parameters;
for (var i = 0; i < parameters.Length; i++)
{
parameters[i].Value = invocation.Arguments[i];
}
var apiAction = context.ApiActionDescriptor;
invocation.ReturnValue = apiAction.Execute(actionContext);
}
/// <summary>
/// 获取异步结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task <object> GetTaskResult(ApiActionContext context)
{
var response = context.ResponseMessage;
var returnType = context.ApiActionDescriptor.ReturnDataType;
if (returnType == typeof(HttpResponseMessage))
{
return(response);
}
if (returnType == typeof(byte[]))
{
return(await response.Content.ReadAsByteArrayAsync());
}
if (returnType == typeof(string))
{
return(await response.Content.ReadAsStringAsync());
}
var message = string.Format("不支持的类型{0}的解析", returnType);
throw new NotSupportedException(message);
}
/// <summary>
/// 获取http请求内容
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的属性</param>
/// <returns></returns>
protected virtual HttpContent GetHttpContent(ApiActionContext context, ApiParameterDescriptor parameter)
{
return(parameter.Value as HttpContent);
}
/// <summary> /// 获取异步结果 /// </summary> /// <param name="context">上下文</param> /// <returns></returns> public abstract Task <object> GetTaskResult(ApiActionContext context);
/// <summary> /// http请求之前 /// </summary> /// <param name="context">上下文</param> /// <param name="parameter">特性关联的参数</param> /// <returns></returns> public abstract Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter);
/// <summary>
/// 获取http请求内容
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
protected override HttpContent GetHttpContent(ApiActionContext context, ApiParameterDescriptor parameter)
{
var json = parameter.Value == null ? null : context.HttpApiClient.JsonFormatter.Serialize(parameter.Value);
return(new StringContent(json, Encoding.UTF8, "application/json"));
}
/// <summary>
/// 执行前
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override Task BeforeRequestAsync(ApiActionContext context)
{
context.RequestMessage.Method = this.Method;
context.RequestMessage.RequestUri = new Uri(context.HostAttribute.Host, this.Path);
return(TaskExtensions.CompletedTask);
}
/// <summary> /// 执行前 /// </summary> /// <param name="context">上下文</param> /// <returns></returns> public abstract Task BeforeRequestAsync(ApiActionContext context);
/// <summary>
/// 请求完成之后
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public virtual Task OnEndRequestAsync(ApiActionContext context)
{
return(TaskExtensions.CompletedTask);
}
/// <summary>
/// 执行api
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public object Execute(ApiActionContext context)
{
return(this.ExecuteAsync(context).CastResult(this.ReturnDataType));
}
