private CodeMemberMethod GenerateMethod(MethodInfo method)
{
var memberMethod = _memberGenerator.GenerateMethodDeclaration(method);
if (method.IsAsync())
{
memberMethod.ReturnType.BaseType = "async " + memberMethod.ReturnType.BaseType;
}
var targetVariable = method.IsAsync()
? new CodeVariableReferenceExpression("await " + WrappedFieldName)
: new CodeVariableReferenceExpression(WrappedFieldName);
CodeExpression invokeExpression =
new CodeMethodInvokeExpression(
targetVariable,
memberMethod.Name,
memberMethod.Parameters.OfType <CodeParameterDeclarationExpression>()
.Select(p =>
{
CodeExpression variableExpression = new CodeVariableReferenceExpression(p.Name);
if (p.Type.IsArray() && IsRegistered(p.Type.ArrayElementType.BaseType))
{
return(InvokeConvertAllWrapper(variableExpression, p.Type.ArrayElementType.BaseType));
}
if (IsRegistered(p.Type.BaseType))
{
variableExpression = new CodePropertyReferenceExpression(variableExpression, WrappedPropertyName);
}
return((CodeExpression) new CodeDirectionExpression(p.Direction, variableExpression));
})
.ToArray()
);
if (memberMethod.ReturnType.BaseType == "System.Void")
{
memberMethod.Statements.Add(invokeExpression);
}
else
{
if (IsRegistered(method.ReturnType))
{
invokeExpression = new CodeObjectCreateExpression(
WrappedTypeDictionary.GetTypeNameFor(method.ReturnType),
invokeExpression
);
}
memberMethod.Statements.Add(new CodeMethodReturnStatement(invokeExpression));
}
return(memberMethod);
}
private void GenerateMethods(IReflect type, CodeTypeDeclaration contract)
{
var methods = type
.GetMethods(BindingFlags.Public | BindingFlags.Instance)
.Where(m => IsExcluded(m) == false);
foreach (var method in methods)
{
contract.Members.Add(_memberGenerator.GenerateMethodDeclaration(method));
}
}
