protected override string GetInvokeArguments(MethodInfo methodInfo)
{
var invokeArguments = string.Empty;
int count = 1;
var parameters = methodInfo.GetParameters();
foreach (ParameterInfo paramInfo in parameters)
{
if (paramInfo.ParameterType.GetInterface("Orleans.Runtime.IAddressable") != null && !typeof(GrainReference).IsAssignableFrom(paramInfo.ParameterType))
{
invokeArguments += string.Format("If(typeof({0}) is Global.Orleans.Grain,{2}.{1}.Cast({0}.AsReference()),{0})",
GrainInterfaceData.GetParameterName(paramInfo),
GrainInterfaceData.GetFactoryClassForInterface(paramInfo.ParameterType),
paramInfo.ParameterType.Namespace);
}
else
{
invokeArguments += GrainInterfaceData.GetParameterName(paramInfo);
}
if (count++ < parameters.Length)
{
invokeArguments += ", ";
}
}
return(invokeArguments);
}
/// <summary>
/// Generate any safeguard check statements for the generated Invoke for the specified method
/// </summary>
/// <param name="methodInfo">The method for which the invoke is being generated for </param>
/// <returns></returns>
protected virtual string GetParamGuardCheckStatements(MethodInfo methodInfo)
{
var paramGuardStatements = new StringBuilder();
foreach (ParameterInfo p in methodInfo.GetParameters())
{
// For any parameters of type IGrainObjerver, the object passed at runtime must also be a GrainReference
if (typeof(IGrainObserver).IsAssignableFrom(p.ParameterType))
{
paramGuardStatements.AppendLine(string.Format(@"GrainFactoryBase.CheckGrainObserverParamInternal({0});",
GrainInterfaceData.GetParameterName(p)));
}
}
return(paramGuardStatements.ToString());
}
/// <summary>
/// Generates a wrapper method that takes arguments of the original method.
/// </summary>
protected override CodeTypeMember GetBasicReferenceMethod(MethodInfo methodInfo, CodeTypeParameterCollection genericTypeParam, bool isObserver)
{
SerializerGenerationManager.RecordTypeToGenerate(methodInfo.ReturnType);
foreach (ParameterInfo paramInfo in methodInfo.GetParameters())
{
SerializerGenerationManager.RecordTypeToGenerate(paramInfo.ParameterType);
}
if (!isObserver)
{
var parameterList = new StringBuilder();
var first = true;
foreach (var p in methodInfo.GetParameters())
{
if (!first)
{
parameterList.Append(", ");
}
first = false;
parameterList.AppendFormat("{0} As {1}", p.Name, GetGenericTypeName(p.ParameterType, type => { }, t => false));
}
var snippet = new StringBuilder();
snippet.AppendFormat("Public Function {0}({1}) As {2} Implements {3}.{0}\n",
methodInfo.Name,
parameterList,
GetGenericTypeName(methodInfo.ReturnType, type => { }, t => false),
GetGenericTypeName(methodInfo.DeclaringType, type => { }, t => false));
snippet.AppendFormat(" {0}\n", GetBasicMethodImpl(methodInfo));
snippet.Append(" End Function\n");
return(new CodeSnippetTypeMember(snippet.ToString()));
}
var referenceMethod = new CodeMemberMethod
{
Name = methodInfo.Name,
ReturnType = GetReturnTypeReference(methodInfo.ReturnType, SerializeFlag.DeserializeResult)
};
foreach (var paramInfo in methodInfo.GetParameters())
{
referenceMethod.Parameters.Add(new CodeParameterDeclarationExpression(
new CodeTypeReference(paramInfo.ParameterType), GrainInterfaceData.GetParameterName(paramInfo)));
}
referenceMethod.Attributes = MemberAttributes.Public | MemberAttributes.Final;
var pit = new CodeTypeReference(GetGenericTypeName(methodInfo.DeclaringType, type => { }, t => false));
referenceMethod.PrivateImplementationType = pit;
var methodImpl = new CodeSnippetStatement(GetBasicMethodImpl(methodInfo));
referenceMethod.Statements.Add(methodImpl);
return(referenceMethod);
}
/// <summary>
/// Returns the C# name for the provided <paramref name="parameter"/>.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The C# name for the provided <paramref name="parameter"/>.</returns>
protected override string GetParameterName(ParameterInfo parameter)
{
return("@" + GrainInterfaceData.GetParameterName(parameter));
}
/// <summary>
/// Returns the Visual Basic name for the provided <paramref name="parameter"/>.
/// </summary>
/// <param name="parameter">The parameter.</param>
/// <returns>The Visual Basic name for the provided <paramref name="parameter"/>.</returns>
protected override string GetParameterName(ParameterInfo parameter)
{
return(string.Format("[{0}]", GrainInterfaceData.GetParameterName(parameter)));
}
