private TypeMetadata LoadSimpleTypeObject(Type type, AssemblyMetadataStore metaStore)
{
TypeMetadata metadataType;
metadataType = new TypeMetadata // add only basic information
{
Id = type.FullName,
Name = type.Name,
NamespaceName = type.Namespace,
Modifiers = EmitModifiers(type),
Kind = GetTypeKind(type),
Attributes = type.GetCustomAttributes(false).Cast <Attribute>(),
Properties = new List <PropertyMetadata>(),
Constructors = new List <MethodMetadata>(),
ImplementedInterfaces = new List <TypeMetadata>(),
Methods = new List <MethodMetadata>(),
NestedTypes = new List <TypeMetadata>()
};
metaStore.TypesDictionary.Add(type.FullName, metadataType);
if (type.IsGenericTypeDefinition)
{
metadataType.GenericArguments = EmitGenericArguments(type.GetGenericArguments(), metaStore);
metadataType.Name =
$"{type.Name}<{metadataType.GenericArguments.Select(a => a.Name).Aggregate((p, n) => $"{p}, {n}")}>";
}
else
{
metadataType.GenericArguments = new List <TypeMetadata>();
}
_logger.Trace("Adding type not declared in assembly being inspected: Id =" + metadataType.Id + " ; Name = " + metadataType.Name);
return(metadataType);
}
private TypeMetadata LoadGenericParameterTypeObject(Type type, AssemblyMetadataStore metaStore)
{
TypeMetadata metadataType;
string id = $"{type.DeclaringType.FullName}<{type.Name}>";
_logger.Trace("Adding generic argument type with Id =" + id);
if (!metaStore.TypesDictionary.ContainsKey(id))
{
metadataType = new TypeMetadata()
{
Id = id,
Name = type.Name,
NamespaceName = type.Namespace,
Modifiers = null,
Kind = GetTypeKind(type),
Attributes = new List <Attribute>(),
Properties = new List <PropertyMetadata>(),
Constructors = new List <MethodMetadata>(),
ImplementedInterfaces = new List <TypeMetadata>(),
Methods = new List <MethodMetadata>(),
NestedTypes = new List <TypeMetadata>(),
GenericArguments = new List <TypeMetadata>()
};
metaStore.TypesDictionary.Add(metadataType.Id, metadataType);
return(metadataType);
}
else
{
return(metaStore.TypesDictionary[id]);
}
}
private TypeMetadata EmitDeclaringType(Type declaringType, AssemblyMetadataStore metaStore)
{
if (declaringType == null)
{
return(null);
}
return(LoadTypeMetadataDto(declaringType, metaStore));
}
private TypeMetadata EmitExtends(Type baseType, AssemblyMetadataStore metaStore)
{
if (baseType == null || baseType == typeof(Object) || baseType == typeof(ValueType) ||
baseType == typeof(Enum))
{
return(null);
}
return(LoadTypeMetadataDto(baseType, metaStore));
}
internal AssemblyMetadataStore LoadAssemblyMetadata(Assembly assembly)
{
AssemblyMetadata assemblyMetadata = new AssemblyMetadata()
{
Id = assembly.ManifestModule.FullyQualifiedName,
Name = assembly.ManifestModule.Name,
};
AssemblyMetadataStore metaStore = new AssemblyMetadataStore(assemblyMetadata);
assemblyMetadata.Namespaces = (from Type type in assembly.GetTypes()
where type.IsVisible()
group type by type.GetNamespace() into namespaceGroup
orderby namespaceGroup.Key
select LoadNamespaceMetadata(namespaceGroup.Key, namespaceGroup, metaStore)).ToList <NamespaceMetadata>();
return(metaStore);
}
internal MethodMetadata LoadMethodMetadataDto(MethodBase method, AssemblyMetadataStore metaStore)
{
if (method == null)
{
throw new ArgumentNullException($"{nameof(method)} argument is null.");
}
MethodMetadata methodMetadataDto = new MethodMetadata()
{
Name = method.Name,
Modifiers = EmitModifiers(method),
Extension = IsExtension(method)
};
methodMetadataDto.GenericArguments = !method.IsGenericMethodDefinition ? new List <TypeMetadata>() : EmitGenericArguments(method.GetGenericArguments(), metaStore);
methodMetadataDto.ReturnType = EmitReturnType(method, metaStore);
methodMetadataDto.Parameters = EmitParameters(method.GetParameters(), metaStore).ToList();
string parameters = methodMetadataDto.Parameters.Any()
? methodMetadataDto.Parameters.Select(methodInstance => methodInstance.Name)
.Aggregate((current, next) => current + ", " + next)
: "none";
string generics = methodMetadataDto.GenericArguments.Any()
? methodMetadataDto.GenericArguments.Select(typeInstance => typeInstance.Id)
.Aggregate((c, n) => $"{c}, {n}")
: "none";
methodMetadataDto.Id = $"{method.DeclaringType.FullName}{method.Name} args {parameters} generics {generics} declaredBy {method.DeclaringType.FullName}";
if (!metaStore.MethodsDictionary.ContainsKey(methodMetadataDto.Id))
{
_logger.Trace("Adding method to dictionary: Id =" + methodMetadataDto.Id);
metaStore.MethodsDictionary.Add(methodMetadataDto.Id, methodMetadataDto);
return(methodMetadataDto);
}
else
{
_logger.Trace("Using method already added to dictionary: Id =" + methodMetadataDto.Id);
return(metaStore.MethodsDictionary[methodMetadataDto.Id]);
}
}
private TypeMetadata LoadFullTypeObject(Type type, AssemblyMetadataStore metaStore)
{
TypeMetadata metadataType = new TypeMetadata()
{
Id = type.FullName,
Name = type.Name,
NamespaceName = type.Namespace,
Modifiers = EmitModifiers(type),
Kind = GetTypeKind(type),
Attributes = type.GetCustomAttributes(false).Cast <Attribute>()
};
_logger.Trace("Adding type: Id =" + metadataType.Id + " ; Name = " + metadataType.Name);
metaStore.TypesDictionary.Add(type.FullName, metadataType);
metadataType.DeclaringType = EmitDeclaringType(type.DeclaringType, metaStore);
metadataType.ImplementedInterfaces = EmitImplements(type.GetInterfaces(), metaStore);
metadataType.BaseType = EmitExtends(type.BaseType, metaStore);
metadataType.NestedTypes = EmitNestedTypes(type.GetNestedTypes(), metaStore);
if (type.IsGenericTypeDefinition)
{
metadataType.GenericArguments = EmitGenericArguments(type.GetGenericArguments(), metaStore);
metadataType.Name =
$"{type.Name}<{metadataType.GenericArguments.Select(a => a.Name).Aggregate((p, n) => $"{p}, {n}")}>";
}
else
{
metadataType.GenericArguments = new List <TypeMetadata>();
}
metadataType.Constructors = EmitMethods(type.GetConstructors(), metaStore);
metadataType.Methods = EmitMethods(type.GetMethods(BindingFlags.DeclaredOnly), metaStore);
metadataType.Properties = EmitProperties(type.GetProperties(), metaStore);
return(metadataType);
}
internal TypeMetadata LoadTypeMetadataDto(Type type, AssemblyMetadataStore metaStore)
{
if (type == null)
{
throw new ArgumentNullException($"{nameof(type)} argument is null.");
}
if (type.IsGenericParameter)
{
return(LoadGenericParameterTypeObject(type, metaStore));
}
else
{
if (!metaStore.TypesDictionary.ContainsKey(type.FullName))
{
TypeMetadata metadataType;
// if type is not declared in assembly being inspected
if (type.Assembly.ManifestModule.FullyQualifiedName != metaStore.AssemblyMetadata.Id) // load basic info
{
metadataType = LoadSimpleTypeObject(type, metaStore);
}
else // load full type information
{
metadataType = LoadFullTypeObject(type, metaStore);
}
return(metadataType);
}
else
{
_logger.Trace("Using type already added to dictionary with key: " + type.FullName);
return(metaStore.TypesDictionary[type.FullName]);
}
}
}
private IEnumerable <TypeMetadata> EmitImplements(IEnumerable <Type> interfaces, AssemblyMetadataStore metaStore)
{
return((from currentInterface in interfaces
select LoadTypeMetadataDto(currentInterface, metaStore)).ToList());
}
private IEnumerable <TypeMetadata> EmitNestedTypes(IEnumerable <Type> nestedTypes, AssemblyMetadataStore metaStore)
{
return((from type in nestedTypes
where type.IsVisible()
select LoadTypeMetadataDto(type, metaStore)).ToList());
}
internal IEnumerable <TypeMetadata> EmitGenericArguments(IEnumerable <Type> arguments, AssemblyMetadataStore metaStore)
{
return((from Type argument in arguments select LoadTypeMetadataDto(argument, metaStore)).ToList());
}
internal IEnumerable <PropertyMetadata> EmitProperties(IEnumerable <PropertyInfo> props, AssemblyMetadataStore metaStore)
{
List <PropertyMetadata> properties = new List <PropertyMetadata>();
foreach (PropertyInfo property in props)
{
if (property.GetGetMethod().IsVisible() || property.GetSetMethod().IsVisible())
{
string id = $"{property.DeclaringType.FullName}.{property.Name}";
if (metaStore.PropertiesDictionary.ContainsKey(id))
{
_logger.Trace("Using property already added to dictionary: Id =" + id);
properties.Add(metaStore.PropertiesDictionary[id]);
}
else
{
PropertyMetadata newProperty = new PropertyMetadata()
{
Id = id,
Name = property.Name
};
_logger.Trace("Adding new property to dictionary: " + newProperty.Id + " ;Name = " + newProperty.Name);
metaStore.PropertiesDictionary.Add(newProperty.Id, newProperty);
properties.Add(newProperty);
newProperty.TypeMetadata = LoadTypeMetadataDto(property.PropertyType, metaStore);
}
}
}
return(properties);
}
private TypeMetadata EmitReturnType(MethodBase method, AssemblyMetadataStore metaStore)
{
MethodInfo methodInfo = method as MethodInfo;
return(methodInfo == null ? null : LoadTypeMetadataDto(methodInfo.ReturnType, metaStore));
}
private IEnumerable <ParameterMetadata> EmitParameters(IEnumerable <ParameterInfo> parameters, AssemblyMetadataStore metaStore)
{
List <ParameterMetadata> parametersMetadata = new List <ParameterMetadata>();
foreach (var parameter in parameters)
{
string id = $"{parameter.ParameterType.FullName}.{parameter.Name}";
if (metaStore.ParametersDictionary.ContainsKey(id))
{
_logger.Trace("Using parameter already added to dictionary: Id =" + id);
parametersMetadata.Add(metaStore.ParametersDictionary[id]);
}
else
{
ParameterMetadata newParameter = new ParameterMetadata(parameter.Name, LoadTypeMetadataDto(parameter.ParameterType, metaStore));
newParameter.Id = id;
metaStore.ParametersDictionary.Add(id, newParameter);
_logger.Trace("Adding parameter to dictionary: Id =" + id);
parametersMetadata.Add(newParameter);
}
}
return(parametersMetadata);
}
internal IEnumerable <MethodMetadata> EmitMethods(IEnumerable <MethodBase> methods, AssemblyMetadataStore metaStore)
{
return((from MethodBase currentMethod in methods
where currentMethod.IsVisible()
select LoadMethodMetadataDto(currentMethod, metaStore)).ToList());
}
internal NamespaceMetadata LoadNamespaceMetadata(string name, IEnumerable <Type> types, AssemblyMetadataStore metaStore)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException($"{nameof(name)} is null/empty/whitespace");
}
NamespaceMetadata namespaceMetadata = new NamespaceMetadata()
{
Id = name,
Name = name
};
_logger.Trace("Adding Namespace to dictionary: " + namespaceMetadata.Name);
metaStore.NamespacesDictionary.Add(namespaceMetadata.Name, namespaceMetadata);
namespaceMetadata.Types = (from type in types orderby type.Name select LoadTypeMetadataDto(type, metaStore)).ToList();
return(namespaceMetadata);
}
