public void FillTree (ICSharpCode.TreeView.SharpTreeView tree,Module module) { var root = CreateTreeItem(module); tree.Root = root; foreach (var ns in module.Namespaces) { var namespaceNode = CreateTreeItem(ns); tree.Root.Children.Add(namespaceNode); foreach (var type in ns.Types) { var typeNode = CreateTreeItem(type); namespaceNode.Children.Add(typeNode); foreach (var method in type.Methods) { var methodName = CreateTreeItem(method); namespaceNode.Children.Add(methodName); } foreach (var field in type.Fields) { var fieldNode = CreateTreeItem(field); namespaceNode.Children.Add(fieldNode); } } } }
/// <summary> /// Reads types from module. /// </summary> /// <param name="module">A module where types will be added</param> /// <param name="types">A collection of types</param> private void ReadTypes(Module module, Collection<TypeDefinition> types) { // first add all types, because i will need find depend types AddTypes(module, types); ReadFromTypes(module, types); }
/// <summary> /// Reads a module from assembly. /// </summary> /// <param name="moduleDefinition">A module which contains information</param> private void ReadModule(ModuleDefinition moduleDefinition) { MainModule = new Module() { Name = moduleDefinition.Name }; Modules.Add(MainModule); if (moduleDefinition.HasTypes) ReadTypes(MainModule, moduleDefinition.Types); }
/// <summary> /// Iterates through a collection of types and add them to the module. /// </summary> /// <param name="module">A module where types will be added</param> /// <param name="types">A collection of types</param> private void AddTypes(Module module, Collection<TypeDefinition> types) { foreach (TypeDefinition typeDefinition in types) { if (typeDefinition.Name != "<Module>") { var type = CreateType(module, typeDefinition); if (typeDefinition.HasNestedTypes) AddNestedTypes(type, typeDefinition.NestedTypes); } } }
/// <summary> /// Reads generic arguments from type and returns them as a set of types /// </summary> /// <param name="module">The module where are types located</param> /// <param name="genericInstance">The instance type</param> /// <returns>A set of types used by generic instance</returns> public ISet<Type> ReadGenericArguments(Module module, GenericInstanceType genericInstance) { var types = new HashSet<Type>(); foreach (var parameter in genericInstance.GenericArguments) { var type = (from n in module.Namespaces from t in n.Types where t.FullName == FormatTypeName(parameter, true) select t).SingleOrDefault(); if (type != null) // types.Add(type); if (parameter.IsGenericInstance) types.UnionWith(ReadGenericArguments(module, (GenericInstanceType) parameter)); } return types; }
/// <summary> /// Reads fields, events, methods from a type. /// </summary> /// <param name="module">A module where are types located</param> /// <param name="types">A collection of types</param> private void ReadFromTypes(Module module, Collection<TypeDefinition> types) { foreach (TypeDefinition typeDefinition in types) { if (typeDefinition.Name != "<Module>") { var type = (from n in module.Namespaces from t in n.Types where t.FullName == FormatTypeName(typeDefinition, true) select t).SingleOrDefault(); if (typeDefinition.BaseType != null) { var baseType = (from n in module.Namespaces from t in n.Types where (t.FullName == FormatTypeName(typeDefinition.BaseType, true)) select t).SingleOrDefault(); type.BaseType = baseType; // if baseType is null so propably inherits from another assembly if (typeDefinition.BaseType.IsGenericInstance) { type.IsBaseTypeGenericInstance = true; type.GenericBaseTypes.UnionWith(ReadGenericArguments(type.Namespace.Module, (GenericInstanceType)typeDefinition.BaseType)); } } // looks for implemented interfaces if (typeDefinition.HasInterfaces) { foreach (var ic in typeDefinition.Interfaces) { var implementedIc = (from n in module.Namespaces from t in n.Types where (t.FullName == FormatTypeName(ic, true)) select t).SingleOrDefault(); if (implementedIc != null) type.ImplementedInterfaces.Add(implementedIc); if (ic.IsGenericInstance) { type.GenericBaseTypes.UnionWith(ReadGenericArguments(type.Namespace.Module, (GenericInstanceType)ic)); } } } if (typeDefinition.HasFields) ReadFields(type, typeDefinition.Fields); if (typeDefinition.HasEvents) ReadEvents(type, typeDefinition.Events); if (typeDefinition.HasMethods) ReadMethods(type, typeDefinition.Methods); if (typeDefinition.HasNestedTypes) ReadFromTypes(module, typeDefinition.NestedTypes); } } }
/// <summary> /// Creates a type. If type exist in namespace which isn't created yet so it will be created. /// </summary> /// <param name="module">A module where type will be added</param> /// <param name="typeDefinition">TypeDefinition which will used to create a type.</param> /// <returns>A new type</returns> private Type CreateType(Module module, TypeDefinition typeDefinition) { var type = new Type { Name = FormatTypeName(typeDefinition), FullName = FormatTypeName(typeDefinition, true), IsInterface = typeDefinition.IsInterface, IsEnum = typeDefinition.IsEnum, IsClass = typeDefinition.IsClass, IsSealed = typeDefinition.IsSealed, IsAbstract = typeDefinition.IsAbstract, IsPublic = typeDefinition.IsPublic, IsStruct = typeDefinition.IsValueType && !typeDefinition.IsEnum && typeDefinition.IsSealed, IsInternal = typeDefinition.IsNotPublic, IsDelegate = (typeDefinition.BaseType != null ? typeDefinition.BaseType.FullName == "System.MulticastDelegate" : false), IsNestedPrivate = typeDefinition.IsNestedPrivate, IsNestedPublic = typeDefinition.IsNestedPublic, IsNestedProtected = (!typeDefinition.IsNestedPrivate && !typeDefinition.IsNestedPublic && typeDefinition.IsNestedFamily) }; // try find namespace var nsName = GetNamespaceName(typeDefinition); var ns = (from n in module.Namespaces where n.Name == nsName select n).SingleOrDefault(); if (ns == null) { ns = new Namespace { Name = nsName, Module = module }; module.Namespaces.Add(ns); } type.Namespace = ns; ns.Types.Add(type); return type; }
public static BitmapSource GetIcon(Module module) { return Assembly; }