/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
async Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var keyValue = new KeyValuePair <string, string>(parameter.Name, this.stringValue);
var httpContent = await context.EnsureNoGet().RequestMessage.Content.MergeKeyValuesAsync(new[] { keyValue });
context.RequestMessage.Content = httpContent;
await TaskExtend.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var ables = this.GetApiParameterables(parameter);
foreach (var item in ables)
{
await item?.BeforeRequestAsync(context, parameter);
}
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
async Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var httpContent = context.EnsureNoGet().RequestMessage.Content.CastOrCreateMultipartContent();
httpContent.AddText(parameter.Name, this.stringValue);
context.RequestMessage.Content = httpContent;
await TaskExtend.CompletedTask;
}
/// <summary>
/// 获取异步结果
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public override async Task <object> GetTaskResult(ApiActionContext context)
{
var response = context.ResponseMessage;
var json = await response.Content.ReadAsStringAsync();
var dataType = context.ApiActionDescriptor.ReturnDataType;
var result = context.HttpApiClient.JsonFormatter.Deserialize(json, dataType);
return(result);
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var header = context.RequestMessage.Headers;
header.Remove(scheme);
if (this.authValue != null)
{
header.TryAddWithoutValidation(scheme, this.authValue);
}
return(ApiTask.CompletedTask);
}
/// <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 TaskExtend.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var ables = this.GetApiParameterables(parameter);
foreach (var item in ables)
{
if (item != null)
{
await item.BeforeRequestAsync(context, parameter).ConfigureAwait(false);
}
}
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public void BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var ables = this.GetApiParameterables(parameter);
foreach (var item in ables)
{
if (item != null)
{
item.BeforeRequestAsync(context, parameter);
}
}
}
/// <summary>
/// 执行一次请求
/// </summary>
/// <returns></returns>
private async Task <TResult> RequestAsync()
{
var context = new ApiActionContext
{
HttpApiConfig = this.httpApiConfig,
ApiActionDescriptor = this.apiActionDescriptor,
RequestMessage = new HttpApiRequestMessage {
RequestUri = this.httpApiConfig.HttpHost
}
};
return(await context.ExecuteActionAsync <TResult>().ConfigureAwait(false));
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var fileInfo = parameter.Value as FileInfo;
if (fileInfo != null)
{
var stream = fileInfo.Open(FileMode.Open, FileAccess.Read);
var fileName = Path.GetFileName(fileInfo.FullName);
var encodedFileName = HttpUtility.UrlEncode(fileName, Encoding.UTF8);
context.RequestMessage.AddMulitpartFile(stream, parameter.Name, encodedFileName, null);
}
return(ApiTask.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 TaskEx.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
public async Task BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
if (parameter.Value is IApiParameterable able)
{
await able.BeforeRequestAsync(context, parameter).ConfigureAwait(false);
}
else if (parameter.Value is IEnumerable <IApiParameterable> array)
{
foreach (var item in array)
{
await item.BeforeRequestAsync(context, parameter).ConfigureAwait(false);
}
}
}
/// <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>
/// 创建请求任务
/// </summary>
/// <returns></returns>
async Task <TResult> ITask <TResult> .InvokeAsync()
{
var context = new ApiActionContext
{
ApiActionDescriptor = this.apiActionDescriptor,
HttpApiConfig = this.httpApiConfig,
RequestMessage = new HttpApiRequestMessage {
RequestUri = this.httpApiConfig.HttpHost
},
ResponseMessage = null
};
return((TResult)await this.apiActionDescriptor.ExecuteAsync(context));
}
/// <summary>
/// 执行一次请求
/// </summary>
/// <returns></returns>
private async Task <TResult> RequestAsync()
{
var context = new ApiActionContext
{
ApiActionDescriptor = this.apiActionDescriptor,
HttpApiConfig = this.httpApiConfig,
RequestMessage = new HttpApiRequestMessage {
RequestUri = this.httpApiConfig.HttpHost
},
ResponseMessage = null
};
var result = await this.RequestAsync(context);
return((TResult)result);
}
/// <summary>
/// 执行请求前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的属性</param>
async Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var method = context.RequestMessage.Method;
if (method == HttpMethod.Get || method == HttpMethod.Head)
{
return;
}
var httpContent = context.RequestMessage.Content.CastMultipartContent();
var fileContent = new MulitpartFileContent(this.GetStream(), parameter.Name, this.FileName, this.ContentType);
httpContent.Add(fileContent);
context.RequestMessage.Content = httpContent;
await TaskExtend.CompletedTask;
}
/// <summary>
/// 执行请求前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
async Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var method = context.RequestMessage.Method;
if (method == HttpMethod.Get || method == HttpMethod.Head)
{
var message = string.Format("{0}方法不支持使用{1}", method, this.GetType().Name);
throw new NotSupportedException(message);
}
var httpContent = context.RequestMessage.Content.CastOrCreateMultipartContent();
httpContent.AddFile(this.GetStream(), parameter.Name, this.FileName, this.ContentType);
context.RequestMessage.Content = httpContent;
await TaskExtend.CompletedTask;
}
/// <summary>
/// http请求之前
/// </summary>
/// <param name="context">上下文</param>
/// <param name="parameter">特性关联的参数</param>
/// <returns></returns>
async Task IApiParameterable.BeforeRequestAsync(ApiActionContext context, ApiParameterDescriptor parameter)
{
var method = context.RequestMessage.Method;
if (method == HttpMethod.Get || method == HttpMethod.Head)
{
var message = string.Format("{0}方法不支持使用{1}", method, this.GetType().Name);
throw new NotSupportedException(message);
}
var keyValue = new KeyValuePair <string, string>(parameter.Name, this.stringValue);
var httpContent = await context.RequestMessage.Content.MergeKeyValuesAsync(new[] { keyValue });
context.RequestMessage.Content = httpContent;
await TaskExtend.CompletedTask;
}
/// <summary>
/// 异步执行http请求
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
private async Task <object> RequestAsync(ApiActionContext context)
{
var apiAction = context.ApiActionDescriptor;
var globalFilters = context.HttpApiConfig.GlobalFilters;
foreach (var actionAttribute in apiAction.Attributes)
{
await actionAttribute.BeforeRequestAsync(context);
}
foreach (var parameter in apiAction.Parameters)
{
foreach (var parameterAttribute in parameter.Attributes)
{
await parameterAttribute.BeforeRequestAsync(context, parameter);
}
}
foreach (var filter in globalFilters)
{
await filter.OnBeginRequestAsync(context);
}
foreach (var filter in apiAction.Filters)
{
await filter.OnBeginRequestAsync(context);
}
var client = context.HttpApiConfig.HttpClient;
context.ResponseMessage = await client.SendAsync(context.RequestMessage);
foreach (var filter in globalFilters)
{
await filter.OnEndRequestAsync(context);
}
foreach (var filter in apiAction.Filters)
{
await filter.OnEndRequestAsync(context);
}
return(await apiAction.Return.Attribute.GetTaskResult(context));
}
/// <summary>
/// 异步执行api
/// </summary>
/// <param name="context">上下文</param>
/// <returns></returns>
public async Task <object> ExecuteAsync(ApiActionContext context)
{
var apiAction = context.ApiActionDescriptor;
var globalFilters = context.HttpApiConfig.GlobalFilters;
foreach (var actionAttribute in apiAction.Attributes)
{
await actionAttribute.BeforeRequestAsync(context);
}
foreach (var parameter in apiAction.Parameters)
{
foreach (var parameterAttribute in parameter.Attributes)
{
await parameterAttribute.BeforeRequestAsync(context, parameter);
}
}
foreach (var filter in globalFilters)
{
await filter.OnBeginRequestAsync(context);
}
foreach (var filter in apiAction.Filters)
{
await filter.OnBeginRequestAsync(context);
}
await this.SendAsync(context);
foreach (var filter in globalFilters)
{
await filter.OnEndRequestAsync(context);
}
foreach (var filter in apiAction.Filters)
{
await filter.OnEndRequestAsync(context);
}
return(await apiAction.Return.Attribute.GetTaskResult(context));
}
/// <summary>
/// 执行Http请求接口
/// </summary>
/// <param name="invocation">上下文</param>
/// <returns></returns>
private Task ExecuteHttpApi(IInvocation invocation)
{
var cache = DescriptorCache.GetApiActionDescriptor(invocation);
var actionDescripter = cache.Clone() as ApiActionDescriptor;
for (var i = 0; i < actionDescripter.Parameters.Length; i++)
{
actionDescripter.Parameters[i].Value = invocation.GetArgumentValue(i);
}
var actionContext = new ApiActionContext
{
ApiActionDescriptor = actionDescripter,
HttpApiConfig = this.httpApiConfig,
RequestMessage = new HttpRequestMessage(HttpMethod.Get, this.httpApiConfig.HttpHost),
ResponseMessage = null
};
return(actionDescripter.Execute(actionContext));
}
///// <summary>
///// 获取ITaskOf(dataType)的构造器
///// </summary>
///// <param name="dataType">泛型参数类型</param>
///// <returns></returns>
//public static ConstructorInfo GetITaskConstructor(Type dataType)
//{
// return typeof(ApiTaskOf<>)
// .MakeGenericType(dataType)
// .GetConstructor(new[] { typeof(HttpApiConfig), typeof(ApiActionDescriptor) });
//}
/// <summary>
/// 创建ApiTaskOf(T)的实例
/// </summary>
/// <param name="httpApiConfig">http接口配置</param>
/// <param name="apiActionDescriptor">api描述</param>
/// <returns></returns>
public static object CreateInstance(HttpApiConfig httpApiConfig, ApiActionDescriptor apiActionDescriptor)
{
var context = new ApiActionContext
{
ApiActionDescriptor = apiActionDescriptor,
HttpApiConfig = httpApiConfig,
RequestMessage = new HttpApiRequestMessage {
RequestUri = httpApiConfig.HttpHost
},
ResponseMessage = null,
Exception = null,
Result = null
};
context.PrepareRequestAsync();
context.ExecRequestAsync();
return(context.Result);
}
/// <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>
/// 执行一次请求
/// </summary>
/// <returns></returns>
private async Task <TResult> RequestAsync()
{
var context = new ApiActionContext
{
ApiActionDescriptor = this.apiActionDescriptor,
HttpApiConfig = this.httpApiConfig,
RequestMessage = new HttpApiRequestMessage {
RequestUri = this.httpApiConfig.HttpHost
},
ResponseMessage = null,
Exception = null,
Result = null
};
await context.PrepareRequestAsync().ConfigureAwait(false);
await context.ExecFiltersAsync(filter => filter.OnBeginRequestAsync).ConfigureAwait(false);
var state = await context.ExecRequestAsync().ConfigureAwait(false);
await context.ExecFiltersAsync(filter => filter.OnEndRequestAsync).ConfigureAwait(false);
return(state ? (TResult)context.Result : throw context.Exception);
}
/// <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 Task BeforeRequestAsync(ApiActionContext context)
{
context.RequestMessage.Method = this.Method;
context.RequestMessage.RequestUri = new Uri(context.HostAttribute.Host, this.Path);
return(TaskEx.CompletedTask);
}
/// <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>
/// JsonRpc请求内容
/// </summary>
/// <param name="context">请求上下文</param>
/// <param name="jsonRpcMethod">请求方法特性</param>
public JsonRpcContent(ApiActionContext context, JsonRpcMethodAttribute jsonRpcMethod)
{
this.context = context;
this.jsonRpcMethod = jsonRpcMethod;
this.Headers.ContentType = new MediaTypeHeaderValue(jsonRpcMethod.ContentType ?? JsonRpc.ContentType);
}