/// <summary>
/// clientWarpper调用代码生成
/// </summary>
/// <param name="returnType"></param>
/// <param name="tokenName"></param>
/// <returns></returns>
private static string ClientInvokeCode(Type returnType, string tokenName)
{
var isAsync = returnType.FullName.StartsWith(typeof(Task).FullName);
if (isAsync)
{
//返回Task
if (returnType == typeof(Task))
{
return($"await _client.SendAsync(request,{tokenName});");
}
//返回Task<ResponseWrapper>
if (returnType == typeof(Task <ResponseWrapper>))
{
return($"return await _client.SendAndWrapAsync(request,{tokenName});");
}
if (returnType.IsGenericType)
{
if (returnType.Namespace == typeof(Task <>).Namespace)
{
var genericArgument = returnType.GenericTypeArguments[0];
if (genericArgument.IsGenericType)
{
var argument = genericArgument.GenericTypeArguments[0];
//返回Task<ResponseWrapper<T>>
if (genericArgument.Namespace == typeof(ResponseWrapper <>).Namespace)
{
var argumentTemplate = new TypeTemplate(argument);
return($"return await _client.SendAndWrapAsync<{argumentTemplate}>(request,{tokenName});");
}
//返回Task<Generic<T>> task内部还是一个泛型类
return($"return await _client.SendAsync<{new TypeTemplate(argument)}>(request,{tokenName});");
}
//返回Task<T>
var template = new TypeTemplate(genericArgument);
return($"return await _client.SendAsync<{template}>(request,{tokenName});");
}
}
}
//返回void
if (returnType == typeof(void))
{
return($"_client.SendAndWrapAsync(request,{tokenName}).GetAwaiter().GetResult();");
}
//返回ResponseWrapper
if (returnType == typeof(ResponseWrapper))
{
return($"return _client.SendAndWrapAsync(request,{tokenName}).GetAwaiter().GetResult();");
}
//返回ResponseWrapper<T>
if (returnType.IsGenericType && returnType.Namespace == typeof(ResponseWrapper <>).Namespace)
{
var genericArgument = returnType.GenericTypeArguments[0];
var template = new TypeTemplate(genericArgument);
return($"return _client.SendAndWrapAsync<{template}>(request,{tokenName}).GetAwaiter().GetResult();");
}
//返回 data
return($"return _client.SendAsync<{new TypeTemplate(returnType)}>(request,{tokenName}).GetAwaiter().GetResult();");
}
public MethodTemplate(MethodInfo method)
{
Method = method;
Name = method.Name;
IsAsync = method.ReturnType.FullName.StartsWith(typeof(Task).FullName);
ReturnType = new TypeTemplate(method.ReturnType);
foreach (var attr in CustomAttributeData.GetCustomAttributes(method))
{
AttributeList.Add(new CustomAttributeTemplate(attr).ToString());
}
//方法参数
foreach (var parameter in method.GetParameters())
{
Parameters.Add(new ParameterTemplate(parameter));
}
if (method.IsGenericMethod)
{
foreach (var argumentType in method.GetGenericArguments())
{
var argument = new GenericArgumentTemplate()
{
Name = argumentType.Name
};
GenericArguments.Add(argument);
if (argumentType.GenericParameterAttributes == GenericParameterAttributes.None &&
argumentType.GetGenericParameterConstraints().Length == 0)
{
continue;
}
//class约束
if (argumentType.GenericParameterAttributes.HasFlag(GenericParameterAttributes.ReferenceTypeConstraint))
{
argument.Constraints.Add("class");
}
//值类型约束
if (argumentType.GenericParameterAttributes.HasFlag(GenericParameterAttributes.NotNullableValueTypeConstraint))
{
argument.Constraints.Add("struct");
}
foreach (var type in argumentType.GetGenericParameterConstraints())
{
argument.Constraints.Add(new TypeTemplate(type).ToString());
}
//无参构造函数
if (argumentType.GenericParameterAttributes.HasFlag(GenericParameterAttributes.DefaultConstructorConstraint))
{
argument.Constraints.Add("new()");
}
}
}
}
