private static Type GetRelevantInterceptorType(MethodInfo method)
{
Type returnType = method.ReturnType;
Type genericArgument;
Type interceptorType;
if (!typeof(Task).IsAssignableFrom(returnType))
{
MethodInfoValidation.ValidateSyncMethod(method);
genericArgument = returnType == typeof(void) ? typeof(object) : returnType;
interceptorType = typeof(SyncCalleeProxyInterceptor <>);
}
else
{
genericArgument = TaskExtensions.UnwrapReturnType(returnType);
if (method.IsDefined(typeof(WampProgressiveResultProcedureAttribute)))
{
MethodInfoValidation.ValidateProgressiveMethod(method);
interceptorType = typeof(ProgressiveAsyncCalleeProxyInterceptor <>);
}
else
{
MethodInfoValidation.ValidateAsyncMethod(method);
interceptorType = typeof(AsyncCalleeProxyInterceptor <>);
}
}
Type closedGenericType = interceptorType.MakeGenericType(genericArgument);
return(closedGenericType);
}
private string GetDelegateType(MethodInfo method)
{
string prefix = GetDelegateNamePrefix(method);
Type returnType = TaskExtensions.UnwrapReturnType(method.ReturnType);
string returnTypeAlias = FormatTypeExtensions.FormatType(returnType);
string result = string.Format("{0}Delegate<{1}>", prefix, returnTypeAlias);
return(result);
}
public T Invoke <T>(ICalleeProxyInterceptor interceptor, MethodInfo method, IOperationResultExtractor <T> extractor, object[] arguments)
{
Type unwrapped = TaskExtensions.UnwrapReturnType(method.ReturnType);
SyncCallback <T> callback = InnerInvokeSync <T>(interceptor, method, extractor, arguments, unwrapped);
WaitForResult(callback);
Exception exception = callback.Exception;
if (exception != null)
{
throw exception;
}
return(callback.OperationResult);
}
public static string GetFormattedReturnType(MethodInfo method)
{
if (!method.ReturnsTuple())
{
return(FormatType(method.ReturnType));
}
else
{
Type returnType = TaskExtensions.UnwrapReturnType(method.ReturnType);
IEnumerable <Type> tupleElementTypes =
returnType.GetValueTupleElementTypes();
TupleElementNamesAttribute tupleElementNamesAttribute =
method.ReturnParameter.GetCustomAttribute <TupleElementNamesAttribute>();
IEnumerable <string> tupleElementsIdentifiers;
IEnumerable <string> tupleElementTypesIdentifiers = tupleElementTypes
.Select(x => FormatType(x));
if (tupleElementNamesAttribute == null)
{
tupleElementsIdentifiers = tupleElementTypesIdentifiers;
}
else
{
tupleElementsIdentifiers =
tupleElementTypesIdentifiers
.Zip(tupleElementNamesAttribute.TransformNames,
(type, name) => $"{type} {name}");
}
string tupleIdentifierContent = string.Join(", ", tupleElementsIdentifiers);
if (typeof(Task).IsAssignableFrom(method.ReturnType))
{
return($"Task<({tupleIdentifierContent})>");
}
else
{
return($"({tupleIdentifierContent})");
}
}
}
private static IWampRpcOperation CreateProgressiveOperation(Func <object> instanceProvider, MethodInfo method, string procedureUri)
{
//return new ProgressiveAsyncMethodInfoRpcOperation<returnType>
// (instance, method, procedureUri);
Type returnType =
TaskExtensions.UnwrapReturnType(method.ReturnType);
Type operationType =
typeof(ProgressiveAsyncMethodInfoRpcOperation <>)
.MakeGenericType(returnType);
IWampRpcOperation operation =
(IWampRpcOperation)Activator.CreateInstance(operationType,
instanceProvider,
method,
procedureUri);
return(operation);
}
public string WriteField(int methodIndex, MethodInfo method)
{
Dictionary <string, string> dictionary = new Dictionary <string, string>();
Type type = method.DeclaringType;
dictionary["methodIndex"] = methodIndex.ToString();
dictionary["delegateType"] = GetDelegateType(method);
dictionary["delegatePrefix"] = GetDelegateNamePrefix(method);
dictionary["interfaceType"] = FormatTypeExtensions.FormatType(type);
Type genericType = TaskExtensions.UnwrapReturnType(method.ReturnType);
dictionary["genericType"] = FormatTypeExtensions.FormatType(genericType);
dictionary["methodName"] = method.Name;
dictionary["defaults"] =
string.Join(", ",
method.GetParameters()
.Select(x => $"default({FormatTypeExtensions.FormatType(x.ParameterType)})"));
return(CodeGenerationHelper.ProcessTemplate(mFieldTemplate, dictionary));
}
public string WriteMethod(int methodIndex, MethodInfo method)
{
string methodField = "mMethod" + methodIndex;
IDictionary <string, string> dictionary =
new Dictionary <string, string>();
ParameterInfo[] parameters = method.GetParameters();
dictionary["methodName"] = method.Name;
dictionary["parameterList"] =
string.Join(", ",
new[] { methodField }.Concat(parameters.Select(x => x.Name)));
dictionary["returnType"] = FormatTypeExtensions.FormatType(method.ReturnType);
string invokeMethod;
if (method.GetCustomAttribute <WampProgressiveResultProcedureAttribute>() != null)
{
invokeMethod = "InvokeProgressiveAsync";
dictionary["parameterList"] =
string.Join(", ",
new[] { methodField }.Concat
(new[] { parameters.Last() }.Concat(parameters.Take(parameters.Length - 1))
.Select(x => x.Name)));
}
else if (typeof(Task).IsAssignableFrom(method.ReturnType))
{
invokeMethod = "InvokeAsync";
}
else
{
invokeMethod = "InvokeSync";
}
Type returnType = TaskExtensions.UnwrapReturnType(method.ReturnType);
if (method.ReturnType != typeof(void))
{
dictionary["return"] = "return ";
dictionary["genericType"] = CodeGenerationHelper.GetGenericType(returnType);
}
else
{
dictionary["return"] = string.Empty;
dictionary["genericType"] = string.Empty;
}
if (method.ReturnType == typeof(Task))
{
dictionary["genericType"] = string.Empty;
}
if (!method.HasMultivaluedResult())
{
invokeMethod = "Single" + invokeMethod;
}
else
{
invokeMethod = "Multi" + invokeMethod;
dictionary["genericType"] = CodeGenerationHelper.GetGenericType(returnType.GetElementType());
}
dictionary["invokeMethod"] = invokeMethod;
dictionary["parametersDeclaration"] =
string.Join(", ",
parameters.Select
(x => FormatTypeExtensions.FormatType(x.ParameterType) + " " + x.Name));
return(CodeGenerationHelper.ProcessTemplate(mMethodTemplate, dictionary));
}
