private NamespaceDeclarationSyntax GenerateSerializers(Assembly targetAssembly, FeatureDescriptions features)
{
var serializerNamespaceMembers = new List <MemberDeclarationSyntax>();
var serializerNamespaceName = $"{SerializerNamespacePrefix}{targetAssembly?.GetName().Name.GetHashCode():X}";
while (this.serializableTypes.GetNextTypeToProcess(out var toGen))
{
if (this.logger.IsEnabled(LogLevel.Trace))
{
this.logger.Trace("Generating serializer for type {0}", toGen.GetParseableName());
}
var type = toGen;
var generatedSerializerName = SerializerGenerator.GetGeneratedClassName(toGen);
serializerNamespaceMembers.Add(SerializerGenerator.GenerateClass(generatedSerializerName, toGen, encounteredType =>
{
string logContext = null;
if (logger.IsEnabled(LogLevel.Trace))
{
logContext = "generated serializer for " + type.GetLogFormat();
}
this.serializableTypes.RecordType(encounteredType, targetAssembly, logContext);
}));
var qualifiedSerializerName = serializerNamespaceName + '.' + generatedSerializerName + GetGenericTypeSuffix(toGen.GetGenericArguments().Length);
features.Serializers.SerializerTypes.Add(
new SerializerTypeDescription
{
Serializer = SF.ParseTypeName(qualifiedSerializerName),
Target = toGen.GetTypeSyntax(includeGenericParameters: false)
});
}
// Add all generated serializers to their own namespace.
return(CreateNamespace(serializerNamespaceName, serializerNamespaceMembers));
}
/// <summary>
/// Generates a syntax tree for the provided assemblies.
/// </summary>
/// <param name="assemblies">The assemblies to generate code for.</param>
/// <param name="runtime">Whether or not runtime code generation is being performed.</param>
/// <returns>The generated syntax tree.</returns>
private GeneratedSyntax GenerateForAssemblies(Assembly targetAssembly, bool runtime)
{
var grainInterfaces = new List <GrainInterfaceDescription>();
var grainClasses = new List <GrainClassDescription>();
var serializationTypes = new SerializationTypeDescriptions();
var members = new List <MemberDeclarationSyntax>();
// Expand the list of included assemblies and types.
var(includedTypes, assemblies) = this.GetIncludedTypes(targetAssembly, runtime);
if (Logger.IsVerbose)
{
Logger.Verbose(
"Generating code for assemblies: {0}",
string.Join(", ", assemblies.Select(_ => _.FullName)));
}
var serializerNamespaceMembers = new List <MemberDeclarationSyntax>();
var serializerNamespaceName = $"{SerializerNamespacePrefix}{targetAssembly?.GetName().Name.GetHashCode():X}";
// Group the types by namespace and generate the required code in each namespace.
foreach (var group in includedTypes.GroupBy(_ => CodeGeneratorCommon.GetGeneratedNamespace(_)))
{
var namespaceMembers = new List <MemberDeclarationSyntax>();
var namespaceName = group.Key;
foreach (var type in group)
{
// Skip generated classes.
if (type.GetCustomAttribute <GeneratedCodeAttribute>() != null)
{
continue;
}
// Every type which is encountered must be considered for serialization.
void OnEncounteredType(Type encounteredType)
{
// If a type was encountered which can be accessed, process it for serialization.
this.typeCollector.RecordEncounteredType(type);
this.serializerGenerationManager.RecordTypeToGenerate(encounteredType, targetAssembly);
}
if (Logger.IsVerbose2)
{
Logger.Verbose2("Generating code for: {0}", type.GetParseableName());
}
if (GrainInterfaceUtils.IsGrainInterface(type))
{
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating GrainReference and MethodInvoker for {0}",
type.GetParseableName());
}
GrainInterfaceUtils.ValidateInterfaceRules(type);
var referenceTypeName = GrainReferenceGenerator.GetGeneratedClassName(type);
var invokerTypeName = GrainMethodInvokerGenerator.GetGeneratedClassName(type);
namespaceMembers.Add(GrainReferenceGenerator.GenerateClass(type, referenceTypeName, OnEncounteredType));
namespaceMembers.Add(GrainMethodInvokerGenerator.GenerateClass(type, invokerTypeName));
var genericTypeSuffix = GetGenericTypeSuffix(type.GetGenericArguments().Length);
grainInterfaces.Add(
new GrainInterfaceDescription
{
Interface = type.GetTypeSyntax(includeGenericParameters: false),
Reference = SF.ParseTypeName(namespaceName + '.' + referenceTypeName + genericTypeSuffix),
Invoker = SF.ParseTypeName(namespaceName + '.' + invokerTypeName + genericTypeSuffix),
InterfaceId = GrainInterfaceUtils.GetGrainInterfaceId(type)
});
}
if (TypeUtils.IsConcreteGrainClass(type))
{
grainClasses.Add(
new GrainClassDescription
{
ClassType = type.GetTypeSyntax(includeGenericParameters: false)
});
}
// Generate serializers.
var first = true;
while (this.serializerGenerationManager.GetNextTypeToProcess(out var toGen))
{
if (first)
{
Logger.Info("ClientGenerator - Generating serializer classes for types:");
first = false;
}
Logger.Info(
"\ttype " + toGen.FullName + " in namespace " + toGen.Namespace
+ " defined in Assembly " + toGen.GetTypeInfo().Assembly.GetName());
if (Logger.IsVerbose2)
{
Logger.Verbose2(
"Generating serializer for type {0}",
toGen.GetParseableName());
}
var generatedSerializerName = SerializerGenerator.GetGeneratedClassName(toGen);
serializerNamespaceMembers.Add(SerializerGenerator.GenerateClass(generatedSerializerName, toGen, OnEncounteredType));
var qualifiedSerializerName = serializerNamespaceName + '.' + generatedSerializerName + GetGenericTypeSuffix(toGen.GetGenericArguments().Length);
serializationTypes.SerializerTypes.Add(
new SerializerTypeDescription
{
Serializer = SF.ParseTypeName(qualifiedSerializerName),
Target = toGen.GetTypeSyntax(includeGenericParameters: false)
});
}
}
if (namespaceMembers.Count == 0)
{
if (Logger.IsVerbose)
{
Logger.Verbose2("Skipping namespace: {0}", namespaceName);
}
continue;
}
members.Add(CreateNamespace(namespaceName, namespaceMembers));
}
// Add all generated serializers to their own namespace.
members.Add(CreateNamespace(serializerNamespaceName, serializerNamespaceMembers));
// Add serialization metadata for the types which were encountered.
this.AddSerializationTypes(serializationTypes, targetAssembly);
// Generate metadata directives for all of the relevant types.
var(attributeDeclarations, memberDeclarations) = FeaturePopulatorGenerator.GenerateSyntax(targetAssembly, grainInterfaces, grainClasses, serializationTypes);
members.AddRange(memberDeclarations);
var compilationUnit = SF.CompilationUnit().AddAttributeLists(attributeDeclarations.ToArray()).AddMembers(members.ToArray());
return(new GeneratedSyntax
{
SourceAssemblies = assemblies,
Syntax = compilationUnit
});
string GetGenericTypeSuffix(int numParams)
{
if (numParams == 0)
{
return(string.Empty);
}
return('<' + new string(',', numParams - 1) + '>');
}
NamespaceDeclarationSyntax CreateNamespace(string namespaceName, IEnumerable <MemberDeclarationSyntax> namespaceMembers)
{
return
(SF.NamespaceDeclaration(SF.ParseName(namespaceName))
.AddUsings(
TypeUtils.GetNamespaces(typeof(GrainExtensions), typeof(IntrospectionExtensions))
.Select(_ => SF.UsingDirective(SF.ParseName(_)))
.ToArray())
.AddMembers(namespaceMembers.ToArray()));
}
}
