public override CodeTypeDeclaration GenerateDeclaration(Type type)
{
ValidateTypeBeforeGeneration(type);
var generatedType = new CodeTypeDeclaration(WrappedTypeDictionary.GetTypeNameFor(type))
{
IsClass = true,
TypeAttributes = _typeGeneratorOptions.GetTypeAttributes() | TypeAttributes.Sealed,
IsPartial = _typeGeneratorOptions.UsePartial
};
generatedType.CustomAttributes.AddExcludeFromCodeCoverage();
generatedType.CustomAttributes.AddGeneratedCode();
generatedType.Comments.Add(new CodeCommentStatement($"Wrapper for {type.GetName()} in {type.Assembly.FullName}"));
generatedType.BaseTypes.Add(WrappedTypeDictionary.GetContractNameFor(type));
generatedType.Members.AddRange(CreateCompositionMembers(type));
GenerateMethods(type, generatedType);
GenerateProperties(type, generatedType);
generatedType.Members.Add(CreateWrappedProperty(type, GenerateAs.Type));
generatedType.Members.Add(CreateConvertWrapperMethod(type));
generatedType.Members.Add(CreateConvertWrappedMethod(type));
return(generatedType);
}
public override CodeTypeDeclaration GenerateDeclaration(Type type)
{
ValidateTypeBeforeGeneration(type);
var contract = new CodeTypeDeclaration(WrappedTypeDictionary.GetContractNameFor(type))
{
TypeAttributes = _contractGeneratorOptions.GetTypeAttributes(),
IsInterface = true,
IsPartial = _contractGeneratorOptions.UsePartial
};
contract.CustomAttributes.AddGeneratedCode();
contract.Comments.Add(new CodeCommentStatement($"Interface for {WrappedTypeDictionary.GetTypeNameFor(type)}"));
if (type.GetInterfaces().Contains(typeof(IDisposable)))
{
contract.BaseTypes.Add("System.IDisposable");
}
GenerateMethods(type, contract);
GenerateProperties(type, contract);
contract.Members.Add(CreateWrappedProperty(type, GenerateAs.Contract));
return(contract);
}
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 CodeMethodInvokeExpression InvokeConvertAllWrapped(CodeExpression array, string elementTypeContract)
{
return(new CodeMethodInvokeExpression(
new CodeTypeReferenceExpression(typeof(Array)),
"ConvertAll",
array,
new CodeMethodReferenceExpression(
new CodeTypeReferenceExpression(
WrappedTypeDictionary.GetTypeNameFor(elementTypeContract)),
ConvertWrappedFunction)
));
}
protected void ValidateTypeBeforeGeneration(Type type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (WrappedTypeDictionary.Registered(type) == false)
{
throw new InvalidOperationException($"Type '{type.GetName()}' must be registered with an IWrappedTypeContainer before a declaration can be generated.");
}
}
private CodeMemberMethod CreateConvertWrappedMethod(Type type)
{
var memberMethod = new CodeMemberMethod
{
Attributes = MemberAttributes.Public | MemberAttributes.Static,
Name = ConvertWrappedFunction,
ReturnType = new CodeTypeReference(WrappedTypeDictionary.GetContractNameFor(type))
};
memberMethod.Parameters.Add(new CodeParameterDeclarationExpression(type, WrappedVariableName));
memberMethod.Statements.Add(
new CodeMethodReturnStatement(
new CodeObjectCreateExpression(WrappedTypeDictionary.GetTypeNameFor(type), new CodeVariableReferenceExpression(WrappedVariableName))));
return(memberMethod);
}
private void BuildPropertyGetter(CodeMemberProperty memberProperty, PropertyInfo property)
{
if (property.IsIndexer())
{
CodeExpression indexerExpression = new CodeIndexerExpression(
WrappedField,
memberProperty.Parameters.Cast <CodeParameterDeclarationExpression>()
.Select(p => new CodeVariableReferenceExpression(p.Name))
.ToArray <CodeExpression>());
if (IsRegistered(property.PropertyType))
{
indexerExpression = new CodeObjectCreateExpression(WrappedTypeDictionary.GetTypeNameFor(property.PropertyType), indexerExpression);
}
memberProperty.GetStatements.Add(new CodeMethodReturnStatement(indexerExpression));
return;
}
if (memberProperty.Type.IsArray() && IsRegistered(memberProperty.Type.ArrayElementType.BaseType))
{
var array = InvokeConvertAllWrapped(
new CodePropertyReferenceExpression(WrappedField, memberProperty.Name),
memberProperty.Type.ArrayElementType.BaseType
);
memberProperty.GetStatements.Add(new CodeMethodReturnStatement(array));
return;
}
CodeExpression expression = new CodePropertyReferenceExpression(WrappedField, memberProperty.Name);
if (IsRegistered(property.PropertyType))
{
expression = new CodeObjectCreateExpression(WrappedTypeDictionary.GetTypeNameFor(property.PropertyType), expression);
}
memberProperty.GetStatements.Add(new CodeMethodReturnStatement(expression));
}
protected bool IsRegistered(string name) => WrappedTypeDictionary.Registered(name);
protected bool IsRegistered(Type type) => WrappedTypeDictionary.Registered(type);
